# GitLab's New Rate Limits: What to Fix Before Oct 19

URL: https://www.devopsness.com/blog/gitlab-rate-limits-october-19-what-to-fix-now
Author: Kiril Urbonas
Published: 2026-10-04
Updated: 2026-11-06
Categories: DevOps
Tags: GitLab, API, CI/CD, DevOps, Automation, News

Summary: GitLab is capping unauthenticated API calls at 60 an hour starting October 19, and the preview windows land before most teams will have noticed.

---
# GitLab's New Rate Limits: What to Fix Before Oct 19

From October 19, 2026, GitLab.com limits unauthenticated requests to 60 per hour per IP address, and Free accounts to 5,000 per hour. The fix is to authenticate everything: send a personal access token or `CI_JOB_TOKEN` on every API call, and replace polling with webhooks. Premium and Ultimate limits follow in January 2027.

> [!VERIFIED]
> GitLab.com plan-based rate limits, against GitLab's September 17, 2026 announcement and the docs.gitlab.com GitLab.com rate limits page. Checked October 2026.

## The schedule, because it's tighter than it looks

GitLab announced the change on September 17, 2026. It previewed the new limits for Free and unauthenticated traffic on October 7 and October 14, from 15:00 to 19:00 UTC, switching them on during those four-hour windows and back off afterwards. Enforcement for unauthenticated traffic and Free accounts begins October 19, 2026. Premium and Ultimate customers get a longer runway: their limits arrive in January 2027. GitLab's stated reason is load: it expects platform load to grow several times over this year, and it wants limits "so no single workload can slow the platform for everyone else."

One wrinkle as of late October 2026: the docs page with the per-plan numbers still labels that table "proposed" and says GitLab announces dates in advance, while the announcement post carries the dates. Don't settle the question by reading pages. Check the `RateLimit-*` headers your own traffic gets back (below).

## The actual numbers

Per GitLab's documentation as of October 2026, the plan limits are:

| Tier | Per user, per hour | Per user, burst per minute | Per top-level group, per minute | Enforced from |
|---|---|---|---|---|
| Unauthenticated (per IP) | 60 | n/a | n/a | October 19, 2026 |
| Free | 5,000 | 100 (300 for web traffic) | 400 | October 19, 2026 |
| Premium | 15,000 | 1,250 | 5,000 | January 2027 |
| Ultimate | 25,000 | 2,000 | 10,000 | January 2027 |

The hourly limit takes precedence: GitLab notes that a Free user running at the burst ceiling hits the hourly limit in about 50 minutes. Limits apply per user and per top-level group, and the plan limits cover API requests, web requests and authenticated Git over HTTPS (each clone, fetch, push or LFS transfer counts as one request). Unauthenticated Git over HTTPS does not count against the 60-per-hour cap; it stays on the existing per-IP limits.

The current ceiling for unauthenticated traffic is 500 requests per minute per IP, so 60 per hour is a cliff, not a tightening around the edges. A CI job that calls the API a few dozen times without a token will sail past 60 in the first twenty minutes of a Monday morning.

## What actually breaks at 60 requests an hour

Nobody writes a script that intentionally hits GitLab's API 60 times an hour unauthenticated. It happens by accident, in a handful of recurring shapes:

- **Webhook polling instead of listening.** A script that checks `GET /projects/:id/pipelines` every 30 seconds to see if a build finished does 120 calls an hour by itself, before anything else runs.
- **CI steps that shell out to curl without a token.** A `.gitlab-ci.yml` step that hits `https://gitlab.com/api/v4/...` to look up a merge request or a release tag, written once by someone in a hurry, with no auth header because it "just worked" in testing.
- **AI coding agents that poll for context.** An agent tool that re-fetches a project's file tree, issue list, or pipeline status on every turn, unauthenticated, racks up requests fast when it's iterating.
- **Shared runners or shared IPs.** GitLab counts unauthenticated requests per IP, so if several jobs or several people share an egress IP, one quiet script can burn through the budget another team needed.

None of these fail today because the old unauthenticated ceiling was generous. After October 19, the first one past 60 gets an `HTTP 429 Too Many Requests` with a `Retry-After` header, and whatever called it either retries into a worse backoff or breaks silently.

## Audit now, not on the 19th

The fix for almost every case above is the same: stop calling the API without credentials. Grep your pipelines and scripts for naked API calls first.

```bash
# find unauthenticated-looking GitLab API calls in your repo
$ grep -rn "gitlab.com/api/v4" --include="*.sh" --include="*.yml" . \
  | grep -v "Authorization\|PRIVATE-TOKEN\|JOB-TOKEN\|CI_JOB_TOKEN"
```

Then confirm a request is authenticated and see your remaining budget in the response headers. Most responses carry `RateLimit-Limit` and `RateLimit-Remaining`, but GitLab's docs note that Projects, Groups and Users API responses don't include these informational headers, so test against another endpoint:

```bash
# authenticate with a personal access token and inspect the rate-limit headers
$ curl -sI --header "PRIVATE-TOKEN: <your-token>" \
  "https://gitlab.com/api/v4/issues?scope=created_by_me&per_page=1" \
  | grep -i ratelimit
```

Inside GitLab CI, the fix is usually one line: use the job's built-in `CI_JOB_TOKEN`. GitLab's docs say authenticating with a CI/CD job token gives you your plan's full limits instead of the anonymous 60. The job token can only call the endpoints GitLab allows it, so use a project access token where it can't.

```yaml
# .gitlab-ci.yml
check_pipeline_status:
  stage: notify
  script:
    - curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/pipelines/latest"
```

For polling scripts outside CI, the real fix is to stop polling. Register a webhook for the event you care about (pipeline status, merge request updates, push events) instead of asking the API every 30 seconds whether anything changed. For AI agents and automation tools that fetch the same project metadata repeatedly, cache the response for a few minutes and batch lookups instead of issuing one call per file or per question.

## Use the preview windows on purpose

Most teams will discover a broken script when it breaks in production on October 19. You don't have to be one of them. The October 7 and October 14 preview windows, 15:00 to 19:00 UTC, are GitLab deliberately giving you a rehearsal with the real limits turned on. Point your staging pipelines and any suspect automation at GitLab during those four-hour windows and watch for `429` responses. That's cheaper than finding out during a release.

## Questions people ask

### What is the GitLab.com unauthenticated API rate limit?

From October 19, 2026, unauthenticated requests to GitLab.com are limited to 60 per hour per IP address, down from the current 500 per minute. Unauthenticated Git over HTTPS clones and fetches don't count against the 60, but API and web calls do. Sending any valid token (personal, project, OAuth or CI/CD job token) moves the request onto your plan's limits instead.

### Does CI_JOB_TOKEN count against GitLab rate limits?

It counts against your plan's limits, not the anonymous ones. GitLab's docs say a CI/CD job token gives you your plan's full allowance, so on Free that's 5,000 requests per hour per user. Runner job requests to `/api/v4/jobs/*` have their own separate limit of 200 per minute. The job token only reaches the endpoints GitLab permits for it.

### When do Premium and Ultimate rate limits start?

January 2027, per GitLab's September 17, 2026 announcement. The numbers are already published: 15,000 requests per hour with a 1,250 per minute burst for Premium, and 25,000 per hour with a 2,000 per minute burst for Ultimate. Self-managed and Dedicated instances are unaffected; their operators set their own limits, though they have a more urgent job this month in [patching GitLab CVE-2026-110264](/blog/gitlab-cve-2026-110264-regex-rce-patch-now).

## The decision, concretely

- **Does any script or CI step call GitLab's API without a token?** Fix it before October 19; unauthenticated traffic is capped at 60 requests per hour starting then.
- **Is a tool polling the API on an interval for status changes?** Replace it with a webhook; polling is the single biggest way to exhaust the new limits.
- **Are you on Free tier with multiple automations sharing one user or group?** Watch the 5,000 per hour and 100 per minute ceilings, plus the 400 per minute group limit; generous for a person, tight for several bots.
- **Are you Premium or Ultimate?** You have until January 2027, but the limits (15,000 and 25,000 requests per hour) are already documented, so audit now while there's no deadline pressure.

## The call we'd make

Treat October 7 and October 14 as free fire drills, not noise to ignore. Grep your scripts for unauthenticated calls, swap them for `CI_JOB_TOKEN` or a personal access token, and replace any polling loop with a webhook before October 19. Teams comparing CI platforms more broadly, including whether to lean on [GitLab CI vs Jenkins](/blog/gitlab-ci-vs-jenkins) or stick with [GitHub Actions against GitLab CI](/blog/github-actions-vs-gitlab-ci), should factor rate limits like these into the total cost of ownership, not just [pricing pages](/blog/github-actions-pricing). The teams that get burned here won't be the ones with heavy automation; they'll be the ones who assumed a quick unauthenticated curl command would keep working forever.

## Sources

- [GitLab blog: Rate limit changes on GitLab.com (September 17, 2026)](https://about.gitlab.com/blog/rate-limit-change-2026/)
- [GitLab Docs: GitLab.com rate limits](https://docs.gitlab.com/user/gitlab_com/rate_limits/)
- [GitLab Docs: GitLab.com settings](https://docs.gitlab.com/user/gitlab_com/)

