Skip to main content
GitLab's New Rate Limits: What to Fix Before Oct 19

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

KU
· Founder & Chief Editor
• 8 min read•Updated •502 views

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

Key takeaways

  • From October 19, 2026, GitLab.com caps unauthenticated requests at 60 per hour per IP address and Free accounts at 5,000 per hour, with Premium and Ultimate following in January 2027.
  • Authenticate every script with a personal access token or CI_JOB_TOKEN, replace polling loops with webhooks, and watch the RateLimit headers.

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 against

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:

TierPer user, per hourPer user, burst per minutePer top-level group, per minuteEnforced from
Unauthenticated (per IP)60n/an/aOctober 19, 2026
Free5,000100 (300 for web traffic)400October 19, 2026
Premium15,0001,2505,000January 2027
Ultimate25,0002,00010,000January 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.

.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.

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 or stick with GitHub Actions against GitLab CI, should factor rate limits like these into the total cost of ownership, not just pricing pages. 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

Explore topics:CI/CDDevOpsNews
React
Share this post
Cite this article
Plain text

Kiril Urbonas (2026). GitLab's New Rate Limits: What to Fix Before Oct 19. DevOpsNess. Updated 2026-11-06. https://www.devopsness.com/blog/gitlab-rate-limits-october-19-what-to-fix-now

Markdown

[GitLab's New Rate Limits: What to Fix Before Oct 19](https://www.devopsness.com/blog/gitlab-rate-limits-october-19-what-to-fix-now) (Kiril Urbonas, DevOpsNess, updated 2026-11-06)

KU

Kiril Urbonas

Founder & Chief Editor

601 articles
View all articles by Kiril Urbonas

You might have missed

Evergreen posts worth revisiting.