golang rate limit per minute

Set the rate you expect :

limiter := rate.NewLimiter(rate.Every(1*time.Minute/20), 20)

for {
    limiter.Wait()
    //more code
}

playground: https://go.dev/play/p/ZpxpHj0vK7P

You seem to look for something that allows "bursts of up to 20, reset every minute". Here is a go at it :

type Limiter struct {
    maxCount int
    count    int
    ticker   *time.Ticker
    ch       chan struct{}
}

func (l *Limiter) run() {
    for {
        // if counter has reached 0: block until next tick
        if l.count <= 0 {
            <-l.ticker.C
            l.count = l.maxCount
        }

        // otherwise:
        // decrement 'count' each time a message is sent on channel,
        // reset 'count' to 'maxCount' when ticker says so
        select {
        case l.ch <- struct{}{}:
            l.count--

        case <-l.ticker.C:
            l.count = l.maxCount
        }
    }
}

func (l *Limiter) Wait() {
    <-l.ch
}

func NewLimiter(d time.Duration, count int) *Limiter {
    l := &Limiter{
        maxCount: count,
        count:    count,
        ticker:   time.NewTicker(d),
        ch:       make(chan struct{}),
    }
    go l.run()

    return l
}

https://go.dev/play/p/5WiOJL5nqCy

try this

import (
    "fmt"
    "time"
)

func main() {
    limiter := time.Tick(3 * time.Minute) //changed from 20 to 3 because i realized you wanted 20 requests per minute, not 1 request per 20 minutes

    for true {
        <-limiter
        fmt.Println(time.Now())
    }
}

I haven't actually tried with 20 * time.Minute as the value, but I tried 200 * time.Milisecond and it worked. Here was my response

2022-05-31 00:06:13.447108 -0600 MDT m=+0.200889915
2022-05-31 00:06:13.651373 -0600 MDT m=+0.405148283
2022-05-31 00:06:13.851522 -0600 MDT m=+0.605291066
2022-05-31 00:06:14.051481 -0600 MDT m=+0.805244205
2022-05-31 00:06:14.250144 -0600 MDT m=+1.003900790
2022-05-31 00:06:14.450952 -0600 MDT m=+1.204703429
2022-05-31 00:06:14.648365 -0600 MDT m=+1.402110595
2022-05-31 00:06:14.848223 -0600 MDT m=+1.601961982
2022-05-31 00:06:15.04909 -0600 MDT m=+1.802823232
2022-05-31 00:06:15.250164 -0600 MDT m=+2.003891217

you can use time.Tick and for-select like this:

package main

import (
    "fmt"
    "time"
)

func main() {
    max := 20

    limiter := time.Tick(1 * time.Minute)

    exit := make(chan struct{})

    go func() {
        count := 0
        exit2 := 0
        defer func() {
            exit <- struct{}{}
        }()
        for {
            select {
            case <-limiter:
                count = 0
                fmt.Println("exit2: ", exit2)
                if exit2 == 3 {
                    return
                }
                exit2++
            default:
                if count == max {
                    continue
                }
                fmt.Println("accepting request", count)
                count++
            }
        }
    }()

    <-exit
}

My solution

import (
        "sync"
        "time"
)

type Limiter interface {
        Wait()
}

type limiter struct {
        tick    time.Duration
        count   uint
        entries []time.Time
        index   uint
        mutex   sync.Mutex
}

func NewLimiter(tick time.Duration, count uint) Limiter {
        l := limiter{
                tick:  tick,
                count: count,
                index: 0,
        }
        l.entries = make([]time.Time, count)
        before := time.Now().Add(-2 * tick)
        for i, _ := range l.entries {
                l.entries[i] = before
        }
        return &l
}
func (l *limiter) Wait() {
        l.mutex.Lock()
        defer l.mutex.Unlock()
        last := &l.entries[l.index]
        next := last.Add(l.tick)
        now := time.Now()
        if now.Before(next) {
                time.Sleep(next.Sub(now))
        }
        *last = time.Now()
        l.index = l.index + 1
        if l.index == l.count {
                l.index = 0
        }
}