Как правильно настроить свой web сервис для множества одновременных запросов по API?

В качетве одного из вариантов можете попробовать через time.Ticker:

var a = &api{
	tick: time.NewTicker(time.Second / 100),
}
defer a.tick.Stop()

func (a *api) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	<-a.tick.C
	log.Println("called")
}

Ссылка на полный пример.

Я бы предложил вариант разделить обязанности по получению запросов, управлению ими и передаче на исполнение.

Например, сделать три независимых сервиса: генератора заданий, менеджера заданий и исполнителя, и соединить их каналами необходимой емкости. Примерно так:

package main

import (
    "context"
    "sync"
    "time"
)

func main() {

    // контекст и группа ожидания
    ctx, cancel := context.WithCancel(context.Background())
    wg := new(sync.WaitGroup)

    // каналы передачи заданий
    taskInputChan := make(chan *Task, 128) // канал входящих заданий
    taskOutputChan := make(chan *Task, 1)  // канал заданий на исполнение

    // запуск сервера, к которому поступают запросы
    // он будет оформлять их заданиями и передавать в канал taskInputChan
    // канал большой емкости, так что переполнения быть не должно
    server := new(Server)
    wg.Add(1)
    go server.Run(ctx, wg, taskInputChan)

    // запуск менеджера заданий
    // он будет решать какое задание отправить в работу
    // и передавать исполнителю по каналу taskOutputChan
    // в канале может находиться только одно задание
    // менеджер сам решит какое, и если нужно - заменит его 
    wg.Add(1)
    go taskManager(ctx, wg, taskInputChan, taskOutputChan)

    // запуск исполнителя заданий
    // он будет получать задания от менеджера и отправлять их в работу
    wg.Add(1)
    go taskRunner(ctx, wg, taskOutputChan)

    // 10 секунд на работу сервиса
    time.Sleep(time.Second * 10)
    cancel()

    // ожидание окончания работы всех гороутин
    wg.Wait()
}

// Task задание
type Task struct{}

// Server
type Server struct{}

// Run запуск сервера
func (s *Server) Run(ctx context.Context, wg *sync.WaitGroup, taskChan chan *Task) {
    defer wg.Done()
}

// taskManager обработчик входящих заданий
func taskManager(ctx context.Context, wg *sync.WaitGroup, taskInputChan chan *Task, taskOutputChan chan *Task) {

    defer wg.Done()

Loop1:
    for {

        select {

        case <-ctx.Done():
            break Loop1

        // получение и обработка задания
        case task := <-taskInputChan:
            handleTask(task, taskOutputChan)
        }
    }
}

// handleTask отправка последнего задания исполнителю
func handleTask(task *Task, taskOutputChan chan *Task) {

    // тут можно реализовать любую логику

    // очистка канала
    select {
    case <-taskOutputChan:
    default:
    }

    // отправка задания в канал
    select {
    case taskOutputChan <- task:
    default:
    }

}

// taskRunner исполнитель заданий
func taskRunner(ctx context.Context, wg *sync.WaitGroup, taskOutputChan chan *Task) {

    defer wg.Done()
    ticker := time.NewTicker(time.Second)

Loop1:
    for {

        select {

        case <-ctx.Done():
            break Loop1

        case <-ticker.C:
            // получение и отправка задания в работу
            task := <-taskOutputChan
            go RunTask(task)
        }
    }
}

// RunTask отправка задания в работу
func RunTask(task *Task) {
    // запрос к внешнему сервису
}

В данной реализации менеджер самый примитивный и кладет в канал на исполнение последнее полученное задание. Логично иметь для менеджера очередь первостепенных заданий и добавлять их в канал на исполнение по мере того как исполнитель будет забирать предыдущие. Настройка и логика работы менеджера целиком зависит от ваших задач. Если запросы однотипные то следует передавать запрос от каждого клиента или даже кэшировать их, если же запросы наоборот имеют ценность только выполненные все целиком (например загрузка большого объема данных по частям), то следует отдать приоритет полной цепочке запросов от одного клиента.