Fix Amazon SP-API 429 QuotaExceeded Errors (Rate Limits)
Fix Amazon SP-API 429 QuotaExceeded errors: how usage plans and token buckets work, plus backoff, rate limiters, batching, reports and notifications.
- Written by
- Md AshikSenior Software Engineer, Artisan Dojo
- Published
- Reading time
- 8 min read
Quick summary30-second read
- An SP-API 429 means you exceeded an operation's usage plan; it is retryable, and occasional transient 429s are unavoidable.
- Amazon rate-limits each operation with a token bucket, mostly per selling partner and application pair, so limits differ per operation.
- The x-amzn-RateLimit-Limit header is best-effort and documented only for 20x, 400 and 404 responses, not for 429s.
- Pace each operation with a limiter keyed by seller, region and operation, and retry with capped exponential backoff and jitter.
- Cut call volume with batch operations, the Reports API and notifications such as ORDER_CHANGE instead of per-item calls and polling.
An Amazon SP-API 429 "QuotaExceeded" error means your application sent more requests to one operation than its usage plan allows, so Amazon rejected the call. The fix is rarely "retry harder". You pace each operation to its documented rate, retry with exponential backoff and jitter, and cut the number of calls with batch operations, reports and notifications.
For how an SP-API integration is built overall, see our Amazon SP-API integration guide.
What does an SP-API 429 QuotaExceeded error mean?
HTTP 429 is "Too Many Requests". Amazon's API models describe it as "the frequency of requests was greater than allowed". In practice the response body usually carries an error with the code QuotaExceeded and a message such as "You exceeded your quota for the requested resource."
Two things matter here:
- A 429 is retryable. Amazon's documentation says so explicitly. The request was not processed, so you can send it again later.
- Some 429s are normal. Amazon states that factors outside your control cause occasional transient 429s, so your code has to expect them.
The real problem is a sync job that hits 429s every run, falls behind, and leaves stock or orders out of date in your ERP.
How do SP-API rate limits work?
Every SP-API operation has a usage plan with two numbers: a rate (requests per second) and a burst (the most requests you can send at once). Amazon enforces it with a token bucket:
- The bucket starts full, holding as many tokens as the burst limit.
- Each request uses one token. No token, no request: you get a 429.
- Tokens refill at the rate, up to the burst limit and never beyond it.
So an operation with rate 0.5 and burst 30 lets you send 30 requests quickly, then roughly one every two seconds.
Most operations are limited per selling partner and application pair: another seller, regional account or application gets its own bucket. Grantless operations follow other criteria. Some APIs add a second limit: the Listings API has one per selling partner account as well as one per account and application pair, and whichever you reach first applies. So a repricer and your ERP integration writing to the same seller account can throttle each other.
Rates differ per operation, and they change
Limits vary a lot. At the time of writing, Amazon's docs list getOrders in Orders API v0 at 0.0167 requests per second with a burst of 20, which is about one request per minute once the burst is gone. The same docs list getOrder at 0.5 with a burst of 30. getItemOffersBatch is listed at 0.1 with a burst of 1.
Don't hard-code these numbers from a blog post, this one included. Amazon can raise limits at any time and announces reductions in advance, so check each operation's API reference page.
Dynamic usage plans
Most operations use standard usage plans with the same static limits for every caller. Some use dynamic usage plans, which Amazon adjusts per selling partner based on business metrics. Amazon is explicit that dynamic rates do not rise because your application calls more often.
What does the x-amzn-RateLimit-Limit header tell you?
When present, the x-amzn-RateLimit-Limit header shows the rate Amazon applied to your request. It helps spot sellers whose limits differ from the defaults. Its limitations:
- It is best-effort. Sometimes Amazon cannot retrieve the limit and sends the response without the header.
- It only comes with certain status codes: 20x, 400 and 404. A 429 is not on that list, so don't expect the header on the response where you would want it most.
- It shows one limit only. Per Amazon, it doesn't include other usage plans that apply to the same operation.
Log it when you get it; fall back to the documented limits when you don't.
How do you fix SP-API 429 errors? Step by step
1. Measure which operations are throttled
Log every response with operation, seller ID, region, status code and x-amzn-RequestId, then group 429s by operation. Usually one or two operations cause most of them.
2. Put a rate limiter in front of each operation
Pace requests to each operation's limit instead of firing them as fast as your workers allow. Key the limiter by seller, region and operation, roughly how Amazon assigns buckets, and set it slightly below the documented rate. Amazon's official SDKs include a built-in rate limiter. Several workers need one shared limiter (for example in Redis), or each spends the full quota on its own.
3. Retry with exponential backoff and jitter
When a 429 arrives anyway, wait longer after each attempt (exponential backoff), add randomness (jitter) so workers don't retry in sync, and cap both the delay and the number of retries, as Amazon's guidance recommends. A small, generic TypeScript version:
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
// Token bucket: refills `rate` tokens per second, holds at most `burst`.
class TokenBucket {
private tokens: number
private last = Date.now()
constructor(private rate: number, private burst: number) {
this.tokens = burst
}
async take(): Promise<void> {
for (;;) {
const now = Date.now()
this.tokens = Math.min(
this.burst,
this.tokens + ((now - this.last) / 1000) * this.rate,
)
this.last = now
if (this.tokens >= 1) {
this.tokens -= 1
return
}
await sleep(((1 - this.tokens) / this.rate) * 1000)
}
}
}
// One bucket per seller + region + operation.
const buckets = new Map<string, TokenBucket>()
function bucketFor(key: string, rate: number, burst: number) {
let b = buckets.get(key)
if (!b) buckets.set(key, (b = new TokenBucket(rate, burst)))
return b
}
// Retry 429 and 5xx with capped exponential backoff and full jitter.
async function callWithRetry(
bucket: TokenBucket,
send: () => Promise<Response>,
maxRetries = 5,
baseMs = 1000,
capMs = 60000,
): Promise<Response> {
for (let attempt = 0; ; attempt++) {
await bucket.take()
const res = await send()
const retryable = res.status === 429 || res.status >= 500
if (!retryable || attempt >= maxRetries) return res
await sleep(Math.random() * Math.min(capMs, baseMs * 2 ** attempt))
}
}
// Example: about 90% of a documented rate of 0.5 req/s, burst 30.
const bucket = bucketFor('SELLER_ID:eu:getOrder', 0.45, 30)
This runs in one process; across processes, move the bucket state into shared storage. When retries run out, requeue the job rather than dropping it.
4. Batch where Amazon offers batch operations
Amazon supports batch operations that bundle up to 20 requests into one call. At the time of writing, the docs list:
- Catalog search:
searchCatalogItemsaccepts up to 20 identifiers in one request. - Pricing and offers:
getItemOffersBatch(by ASIN),getListingOffersBatch(by SKU),getCompetitiveSummaryandgetFeaturedOfferExpectedPriceBatch. - Fees:
getMyFeesEstimates.
One batch call uses one token but does the work of many. For writing stock and prices, the JSON_LISTINGS_FEED in the Feeds API plays the same role.
5. Use reports for bulk reads
A sync that loops over every SKU or order to read data will hit limits as the catalog grows. The Reports API returns inventory, order and settlement data as files in a handful of calls. Amazon recommends reports for historical data and backfills, ideally off-peak. Reports have rate limits too, so don't poll getReport in a tight loop.
6. Replace polling with notifications
Polling spends quota whether or not anything changed. The Notifications API pushes events to Amazon SQS or Amazon EventBridge, depending on the type. Useful ones for ERP and inventory syncs:
ORDER_CHANGE: important order changes, such as status changes and buyer-requested cancellations (SQS).REPORT_PROCESSING_FINISHED: a report you requested reachedDONE,CANCELLEDorFATAL(SQS).ANY_OFFER_CHANGED: changes to the top offers or Buy Box for an item you sell (SQS).LISTINGS_ITEM_STATUS_CHANGEandLISTINGS_ITEM_MFN_QUANTITY_CHANGE: listing status and seller-fulfilled quantity changes (EventBridge).FBA_INVENTORY_AVAILABILITY_CHANGES: FBA inventory quantity changes (SQS).
Call the API when an event says something changed, and keep a slower scheduled sync as a safety net.
Top tip
The quickest win is often orders. Instead of calling the order search operation every minute, subscribe to ORDER_CHANGE, fetch the changed order, and run a wider catch-up search a few times per hour.
7. Cache and spread work over time
- Cache data that rarely changes, such as catalog attributes and product type definitions.
- Avoid spikes. Starting every job at minute 0 drains the burst. Spread work across the hour and across sellers.
- Send deltas. Push only changed stock and prices, plus a scheduled full reconciliation.
8. Make retries safe
Retries are only harmless if repeating a request does no damage. Use the Amazon order ID as a unique key so a re-imported order never becomes two ERP orders. For writes such as shipment confirmations, check the current state before resending.
9. Monitor 429 rates
Track 429s per operation and seller as a rate, and alert when it stays high or a sync falls behind. A steady rise means your call pattern is being outgrown. This ongoing watching is what integration maintenance covers.
Symptom, likely cause, fix
| Symptom | Likely cause | Fix |
|---|---|---|
| 429s at the start of every scheduled run | All jobs start at once and drain the burst | Rate limiter per operation; stagger start times |
| Order search throttled all day | Polling the order search every minute | ORDER_CHANGE notifications plus a slower catch-up sync |
| Pricing sync never finishes | One offers call per SKU | getListingOffersBatch or getItemOffersBatch, or ANY_OFFER_CHANGED |
| Full inventory read takes hours | Per-item API calls for bulk data | Reports API, triggered by REPORT_PROCESSING_FINISHED |
| Listings writes throttled though your app is quiet | Another tool shares the seller's account-level limit | Coordinate tools; use JSON_LISTINGS_FEED for bulk writes |
| Duplicate orders in the ERP after errors | Retries without idempotency | Unique key on Amazon order ID |
| Limits worked last month, not now | Limit changed or volume grew | Check the docs and x-amzn-RateLimit-Limit; review call pattern |
Common mistakes
- Retrying immediately in a loop, which keeps you throttled.
- One limiter for the whole app, when limits are per operation and per seller.
- Hard-coding limits from old posts instead of reading the current docs.
- Relying on
x-amzn-RateLimit-Limit, especially on the 429 itself. - Testing rate limits in the sandbox. You can test 429 handling there, but all sandbox operations share the same rate.
- Each worker running its own limiter, together sending several times the allowed rate.
For the rest of the checklist beyond throttling, see the marketplace ERP integration checklist.
Frequently asked questions
Can I ask Amazon to raise my SP-API rate limit?
Amazon says limits are right-sized and points constantly throttled applications to optimizing their call patterns. Dynamic plans adjust on business metrics, not call volume.
Does the 429 response tell me when to retry?
Not reliably. The x-amzn-RateLimit-Limit header is documented for 20x, 400 and 404 responses, not for 429s. Use the documented rate for that operation and an exponential backoff with jitter.
Will adding more sellers to my app cause more throttling?
No. Most usage plans are per selling partner and application pair, so each new seller gets their own buckets. Grantless operations follow other criteria, and some APIs also have application-level limits.
Why do I get 429s even though I stay under the documented rate?
Common reasons: a second limit on the operation (like the Listings API's account-level limit), another tool calling for the same seller, workers without a shared limiter, or a dynamic plan with a different rate. Some transient 429s are also unavoidable.
Is it safe to retry every 429?
It is safe to retry a 429 itself, because Amazon did not process the request. Make sure the surrounding job is idempotent, though, so a retry after a timeout or 5xx error can't create duplicates.
Need help with a throttled integration?
If your Amazon sync keeps falling behind because of 429s, we can help. Artisan Dojo builds and maintains Amazon SP-API integrations for sellers and agencies in Europe and the US. Tell us which operations are failing and how your sync is built, and we will tell you what we would change first.