Storefront API cartCreate returning THROTTLED error despite no documented limits

Shopify Discussion
, , ,
1

Hi everyone,

I’m running into a throttling issue with the Storefront API and wanted to check if anyone else has experienced the same.

I was testing the new Shopify API usage limits (docs: https://shopify.dev/docs/api/usage/limits) and when I call the cartCreate mutation on the Storefront API, I get this response:

{
  "data": {
    "cartCreate": {
      "cart": null,
      "userErrors": []
    }
  },
  "errors": [
    {
      "message": "Throttled",
      "path": ["cartCreate"],
      "extensions": {
        "code": "THROTTLED"
      }
    }
  ]
}

From what I see in the documentation, there are no usage limits mentioned for the Storefront API, but I’m still hitting this THROTTLED error.

A few questions I’m hoping to clarify:

  • Are there hidden or undocumented rate limits specifically for cartCreate in the Storefront API?

  • Could this be related to store plan limits or infrastructure-level throttling?

  • Is the throttling based on per-IP, per-session, or per-shop limits?

  • Has anyone found a workaround or best practice for handling these throttled requests (e.g., retries with backoff)?

Any guidance or insights would be really helpful. Thanks in advance!

1 Like
3

You’re not imagining it — the cartCreate mutation can return a THROTTLED error even though the Storefront API docs don’t spell out explicit rate limits. A few things to know:

  1. Hidden Limits Exist → The Storefront API enforces throttling under the hood, especially for cart-related operations. While general Storefront API requests follow the cost-based system, cartCreate in particular has additional safeguards since it writes to Shopify’s cart/checkout infrastructure.

  2. It’s Per-Shop / Per-IP Based → In practice, throttling can trigger if you fire multiple cartCreate requests in quick succession (e.g., load testing, bots, or rapid checkout flows). It’s not tied to your plan, but infrastructure-level protection.

  3. Best Practice → Treat cart creation as a relatively expensive operation.

    • Create one cart per session and reuse it instead of creating new carts repeatedly.

    • If you do need multiple requests, add retry logic with exponential backoff (e.g., wait 200ms, then 400ms, 800ms, etc.).

    • Avoid firing multiple cartCreate requests in parallel.

  4. Extra Tip → You can track rate limit headers with Storefront API requests (X-Request-ID and cost headers) to see if you’re close to hitting limits. While not fully exposed for cartCreate, they can give some context.

So, to your direct questions:

  • Yes, there are practical limits even if not documented.

  • They’re infra-level, not plan-based.

  • Likely enforced per-IP/session/shop.

  • Workaround = reuse carts + add retry/backoff logic.

If you’re still hitting the wall with normal usage patterns, it might be worth raising it with Shopify Support since sometimes throttling can be mis-triggered on high-traffic stores.

1 Like
4

Yes, cartCreate does have hidden throttling tied to shop/session limits. Add retries with backoff and avoid parallel bursts. If it persists, contact Shopify support. For consent/data handling, Ketch can also help.

1 Like
5

Hey CwsSanket,

I’ve dealt with this throttling issue a few times, so let me give you a bit of clarity based on what I’ve found and from general Shopify API best practices.

  1. Are there hidden or undocumented rate limits specifically for cartCreate in the Storefront API?

    • Shopify doesn’t have explicit rate limits for most endpoints in the Storefront API documented like the Admin API, but the Storefront API does have limits in place that are enforced by Shopify’s backend. Even though it’s not documented explicitly for certain mutations like cartCreate, there are still limits to prevent abuse and protect the service from overloading.

    • It’s possible that cartCreate is affected by these limits indirectly, especially if you’re making a lot of requests in a short period.

  2. Could this be related to store plan limits or infrastructure-level throttling?

    • Store plan limits: Generally, Shopify limits related to rate limits and API usage are not tied to the store plan, so throttling should not be influenced directly by whether you’re on Basic, Shopify, or Plus. But if you’re hitting those limits regularly, it could be an indication of needing a more optimized request flow, especially if your store has a high volume of traffic.

    • Infrastructure-level throttling: This is more likely. Shopify might be rate-limiting based on global infrastructure rules, which are not necessarily tied to your store plan but more to the scale and volume of requests hitting the system.

  3. Is the throttling based on per-IP, per-session, or per-shop limits?

    • It’s a mix of all three. The exact details of how Shopify enforces throttling are not fully disclosed, but it’s safe to assume that they might throttle based on:

      • Per-IP: If many requests come from the same IP, it could trigger throttling.

      • Per-session: If too many requests are made during a single user session, it might be throttled.

      • Per-shop: Shopify could enforce limits per-shop as well, especially if the shop is making multiple rapid requests across different parts of the API.

  4. Has anyone found a workaround or best practice for handling these throttled requests (e.g., retries with backoff)?

    • Backoff strategy: Shopify recommends implementing retries with exponential backoff when dealing with throttling. This means if you hit the throttle limit, wait a short time, retry, then gradually increase the wait time between retries. This helps you avoid bombarding the API and also respects Shopify’s limits.

    • Queueing requests: Another good practice is to queue your requests, making sure you’re not overwhelming the API. You could implement a queue system where requests are batched or queued and only processed after a delay (e.g., a few seconds or a minute).

    • Request optimization: Look at how often and in what pattern you’re hitting the cartCreate mutation. You could try to minimize unnecessary calls or ensure that you’re only making calls when absolutely necessary.

1 Like
6

There is nothing hidden – Shopify API limits

All Shopify APIs use a leaky bucket algorithm to manage requests.