# Shopify API Guide: How the 5 APIs Work (2026)

By Mohammed Bakari · 2026-11-19 · Source: https://www.activepieces.com/blog/shopify-api-guide-how-the-5-apis-work-2026

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>Shopify APIs use query-cost throttling not per-call fees; REST Admin is legacy; mutations burn roughly ten times as much budget as reads.</p><ul><li>REST Admin API is legacy; migrating to GraphQL becomes necessary eventually.</li><li>API versions retire; Shopify ships quarterly updates with at least twelve months of support.</li><li>Five Shopify APIs serve different purposes; selecting the wrong one breaks your implementation.</li></ul></aside>

The [Shopify](https://shopify.dev/docs/apps/build/apis/graphql-admin/rate-limits) API is a family of APIs, mostly GraphQL, that an app calls with an access token, whether the app is a custom build or a workflow wired up in a tool like [Activepieces](https://www.activepieces.com).

**Shopify charges no per-call fee**, but app type, scopes and rate limits decide what you can do.

The figures here follow Shopify's developer documentation as of 19 November 2026.

## Learn Shopify API access and scopes

### Admin, Storefront and Customer Account APIs

Pick the wrong API and you end up building against something that can't do your job. "Shopify API" usually means the Admin API, which manages a store's back office. The other APIs serve different callers.

<blockquote class="pull"><p>Pick the wrong API and you end up building against something that can't do your job.</p></blockquote>

The table shows who calls each API, what it touches and whether a token is required. Start with the first row if you're automating your own store.

| API | Who calls it | Reads or writes | Access token | Protocol |
|---|---|---|---|---|
| Admin API | Your backend, a custom app or a public app | Products, orders, customers, inventory | Yes | GraphQL primary, REST legacy |
| Storefront API | A headless site or mobile app | Catalogue, cart, checkout | Yes, public or private | GraphQL |
| Customer Account API | A storefront acting for a signed-in customer | That customer's orders, profile, addresses | Yes, via customer login | GraphQL |
| Partner API | Agencies and app developers | Partner-level data on apps and stores | Yes | GraphQL |
| Payments Apps API | Payment providers | Payment sessions, refunds | Yes | GraphQL |

Look down the token column and every row says yes, so none of these accepts anonymous calls. Next comes the question of query language.

Start in GraphQL. Shopify treats the Admin API's REST version as legacy, so new work should begin with the GraphQL Admin API instead. **Building on REST now means a migration later**. The other four APIs in the table have no REST option at all.

Nothing per call. The price is effort: Shopify throttles calls by query cost, not by request count, so a heavy query can exhaust your allowance faster than many light ones.

You can write the throttling and retry handling yourself, or you can describe the job to the built-in chat in [Activepieces](https://www.activepieces.com), say tagging each new order and retrying when Shopify throttles it.

The chat publishes a live flow, the same thing a builder would have wired by hand, and it sits under the same RBAC and audit logs as every other flow. MoneyGram, Moneypenny, Alan and FundingSocieties run Activepieces in production.

![Activepieces workflow builder with HTTP request step selected and its settings panel open showing method, URL, headers, and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9e36e973-de4a-435f-8912-12e666216b2d/self-host-mistral-ai-enterprise-deployment-guide-3f7fe28d.webp)

Open its run trace and anyone can read what happened without knowing the cost arithmetic.

## Get a Shopify API key and access token

You get Shopify credentials by creating an app and installing it. The app can live inside one store's admin for a single shop, or in a Partner or Dev Dashboard account for many, and either way you copy the Admin API access token it issues.

Knowing the limits exist is half the job; this is the other half, and the route you pick decides how much setup you carry.

To choose between the three routes, the table compares them on what you need, where you build, how the app gets installed, what token you receive and whether it suits one store or many.

Read it as a decision aid. If the app will only ever touch your own shop, the last row is the cheapest path, and the other two exist for apps that must live on shops you don't own.

| | Account or plan needed | Where created | How installed | Token type | One store or many |
|---|---|---|---|---|---|
| Dev Dashboard app | Dev Dashboard account | Dev Dashboard | Installed on a store through an install link or the OAuth flow | OAuth access token | Many |
| Partner-account app | Shopify Partner account | Partner Dashboard | Installed through the OAuth flow, or a custom distribution link | OAuth access token | Many |
| Store-level custom app | A Shopify store you administer | The store's own admin | Installed directly inside that store | Admin API access token, shown in the admin | One |

Check Shopify's developer docs for the current menu names, since Shopify has moved these screens before.

### Custom app for one store

Use this if you run one shop and want the quickest route. From the store admin, enable custom app development, create the app, set its Admin API scopes, install it, and reveal the token.

Copy it immediately and store it in a secrets manager or environment variable, because the admin shows it only once.

Skip the extra account, the hosting and the OAuth code. That is the bootstrap version.

### Partner or Dev Dashboard app for many stores

Use this when you build for clients or plan to distribute the app. You create it in the dashboard, then each store installs it and grants permission, and your server exchanges the result for a token per store.

That means you host a redirect URL and handle the exchange yourself.

When an install is revoked, that shop's token is dead, and you are left maintaining one token per shop.

Request only the scopes the workflow needs, such as reading orders or writing products. Broad scopes widen the damage if a token leaks, and for distributed apps they invite more scrutiny from store owners.

![A workflow automation interface showing the execution and configuration of an HTTP request that revokes an API token using…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/d55bf56e-a650-41bf-a158-7c61b4ee1fc4/how-to-connect-a-reddit-integration-in-2026-step-535ff857.webp)

Changing scopes later usually means reinstalling or re-approving the app, so list the data you touch before you click install.

## Authenticate Shopify API requests step by step

Send an access token in the X-Shopify-Access-Token header with every request, and know that it can only reach the scopes you chose at install. How you get the token depends on whether the app serves one store or many.

![Request header card with an access token line sent to a server](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/80eb1113-3d1d-49e3-b950-568229eb2469/shopify-api-guide-how-the-5-apis-work-2026-illus-19bec1ef.webp)

### Token header for custom apps

If you're building for your own store, the bootstrap version is a custom app created in the store admin. Installing it shows you an Admin API access token, and you paste that into the header of each call.

There's no redirect, no callback and no code exchange, so a beginner with one store can skip OAuth entirely. The catch is that the token works for that store only.

### OAuth flow for distributed apps

If merchants you don't own will install your app, you need the OAuth authorization code flow.

The sequence below shows what your server and the merchant each do, and the thing to take from it is that your code does the verifying at steps three and four, not Shopify.

1. Redirect the merchant to Shopify's authorize URL, with your requested scopes in the query.
2. The merchant reviews those scopes and approves the install.
3. On the callback, verify the HMAC signature and the state value you set earlier. Reject the request if either fails.
4. Exchange the temporary authorization code for a permanent access token.
5. Store that token server-side, tied to the shop.
6. Send it in the X-Shopify-Access-Token header on every later call.

![Four-step install flow with server checking HMAC signature and state](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/be28b9af-3cce-4bed-85c8-ad153b08c472/shopify-api-guide-how-the-5-apis-work-2026-illus-c9f8382e.webp)

Skip the checks at step three and you've made the usual mistake. The HMAC proves the request came from Shopify, and the state value proves the callback answers a redirect you started. The full parameters are in [Shopify's authentication docs](https://shopify.dev/docs/apps/build/authentication-authorization).

### Store your Shopify API access token securely

**Keep the token in server-side storage or an encrypted environment variable, never in browser code.**

When anything is shipped to a browser, any visitor who opens the developer tools can read it, and a leaked Admin API token gives them the same reach you have.

Keep it out of public repositories too. If one leaks, rotate it or reinstall the app to get a new one.

## A minimal working Shopify API request

With a token in hand, the smallest useful call is one POST to your shop's versioned GraphQL endpoint asking for the shop name. If it returns the name, your token, scopes and URL are all correct.

![A completed flow run showing trigger and step execution with HTTP request details and success status](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/bf7801a3-7dea-4788-a83a-1d3dde0fbc59/what-actually-transfers-when-you-migrate-off-aut-3c5ad478.webp)

```bash
curl -X POST \
 "https://YOUR-SHOP.myshopify.com/admin/api/2025-10/graphql.json" \
 -H "Content-Type: application/json" \
 -H "X-Shopify-Access-Token: YOUR_TOKEN" \
 -d '{"query":"{ shop { name } }"}'
```

Try it on a free development store, the bootstrap version, so a typo costs nothing. The dated segment in the URL is the API version, and the token travels in the header, never the URL.

### Read the Shopify API response and query cost

When the call works, the reply has a `data` object holding `shop.name`, plus an `extensions.cost` block reporting what the query cost and how much budget remains. Per [Zato's rate-limit guide](https://zato.io/docs/dev/shopify/rate-limits-and-backoff.html), a scalar field such as `name` costs 0 points, so reading plain values is free.

![What common GraphQL operations cost in points](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/4a667eaf-c70f-481a-a4ed-8247672044cb/shopify-api-guide-how-the-5-apis-work-2026-stack-31f4842c.svg "Source: Zato")

So the whole call costs 1. [Zato](https://zato.io/docs/dev/shopify/rate-limits-and-backoff.html:**) states that an object field such as `shop` costs 1.

According to Zato, a connection, such as a list of products, has a base cost of 2 before the items inside it add their own, and a mutation starts at 10. **Writes burn budget about ten times faster** than the simplest reads, so batch them.

![One shared water jug feeding two cups: a thin trickle fills a small cup, while a wide-open flow drains the jug ten times…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/229b8970-35c2-4b9c-a98e-f763b6213544/shopify-api-guide-how-the-5-apis-work-2026-illus-7addfcb7.webp)

When the run completes, an authenticated POST looks like the one below: green checks, a 200 status and a duration in milliseconds. A 200 can still carry an `errors` array, so check the body, not just the status.

*(screenshot)*

With one call confirmed, the version in the URL is the next thing to settle.

### Pinning an API version

**Every quarter, Shopify ships a new dated version** and supports each one for at least 12 months, per its versioning docs. Pin an explicit version, such as `2025-10`, so your integration behaves the same tomorrow.

Leave the version out and Shopify routes you to the oldest supported one.

Put a calendar reminder on the retirement date, because an unpinned or expired version changes behavior without warning.

## Shopify API rate limits by plan and API

Before you trust any figure, know that Shopify's limits differ by API and by the store's plan, and they shift over time like versions do. Check the numbers in Shopify's developer docs on the day you build.

GraphQL Admin spends query-cost points, REST Admin counts requests, and the Storefront API is built for shopper traffic.

For each API, the table shows the unit it meters and how its refill behaves. The figures are left out because I have no confirmed ones to cite. Take the structure from it, then read current values off the docs page for your API version.

| API | Limit unit | Restore behavior | Plan effect |
|---|---|---|---|
| GraphQL Admin | Query cost points | Bucket refills continuously | Higher plans get a larger bucket and faster refill |
| REST Admin | Requests | Bucket drains at a steady rate | Higher plans get a larger bucket |
| Storefront API | Buyer-facing requests | Not a store-wide bucket like Admin | Built for shopper traffic |

Whichever API you pick, one sloppy loop can drain the bucket, and your sync then stalls until it refills.

When you send a query, it is priced by the fields and connections it requests, and the price comes out of a bucket that refills at a set rate.

The response's `extensions` block reports the requested cost, the actual cost, and a `throttleStatus` with the bucket's maximum, what's currently available, and the restore rate. Ask for fewer fields and your cheap queries stop competing with each other.

With REST, a trivial call and a heavy one weigh the same, because it counts calls, not cost. The `X-Shopify-Shop-Api-Call-Limit` header shows how full your bucket is. When it overflows you get a `429` with a `Retry-After` header, so wait that long before retrying.

Keep back-office jobs off the Storefront API, which serves buyer-facing reads. For large exports, the bootstrap version is a GraphQL bulk operation. It runs asynchronously and returns a file, so you skip the per-query bucket arithmetic.

## Fix common Shopify API errors

For the heavy reads, bulk operations cover you, but everything else still fails in a short list of predictable ways, each with a direct fix.

The list below works as a triage card: match the symptom, apply the fix, and you clear most outages without paying for support.

- 401 means the token is wrong, revoked or expired, so reissue it or repeat the install flow.
- 403 means the app lacks the scope, so add it and have the merchant approve again.
- 404 often means the version in your URL has been retired, so update the version string.
- 422 means the payload failed validation, so read the response body for the field it names.
- 429 means you were throttled, so wait for the Retry-After period before retrying.
- An errors array inside a 200 means the GraphQL request failed, so read the body, not the status.
- userErrors in a mutation response mean Shopify rejected your input, so correct the fields listed.

The four cases below cost builders the most time.

Don't mix up the two: a 401 is about identity and a 403 is about permission. Don't fix a 403 by regenerating the token. Request the missing scope, then reinstall or re-authorize so the new permission attaches to a fresh token.

Honor Retry-After instead of retrying in a tight loop, which only extends the lockout. The bootstrap fix for polling is to subscribe to webhooks and let Shopify push changes to you.

Orders can silently fail to update while your client logs success, because GraphQL reports many failures with a success status. Your client must inspect the errors array and each mutation's userErrors. Paginate with cursors, not offsets.

Nobody touched the integration, and it starts returning 404s, because versions are retired on a schedule. Pin a version deliberately and review it regularly instead of **discovering the retirement in production**.

## Call the Shopify API without code in Activepieces

When your job is order, product or customer automation triggered by a store event, Activepieces fits, and the free plan covers it: unlimited flows and 1,000 credits a month, with a run costing 1 credit however many steps it has.

![A workflow canvas showing an Instance Stopped trigger connected to a Revoke Token HTTP request step, with the right panel…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/6562aaca-2f20-4c5f-929c-5a24b3c9a908/linkedin-api-access-limits-and-errors-in-2026-sc-d387a7d6.webp)

It handles the connection, the trigger and the request plumbing so you describe the flow instead of coding it.

Even a version you pinned and reviewed has to be maintained somewhere, and here the integration is where that upkeep sits, not in your own script.

Start with a free tier or self-hosted install, a custom app on your own store, and one token. That covers a lot of small-shop work: tagging orders, notifying a packer, adding customers to a mailing list.

### Connect a store with an access token

Create a custom app in your Shopify admin, grant it only the scopes the flow needs, and copy the Admin API access token it gives you.

Paste the store domain and that token into the Shopify connection in Activepieces; on the free plan, that connection can feed as many flows as you build, since flows are unlimited on every plan.

![Admin dashboard showing AI usage metrics, spending by source, project costs, and AI model usage breakdown with charts and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ea1d663a-9db3-4541-8961-a76af556747d/google-antigravity-mcp-how-to-add-servers-2026-s-d0008d5d.webp)

If the scope list is narrow, a leaked connection can read orders but not touch products, so choose it deliberately.

The Ultimate plan lists secret managers alongside SCIM, custom RBAC and audit logs, and with it that token can sit in your own secret manager instead of Activepieces' database.

The token is the same credential you'd use calling Shopify directly, which matters in the next step.

### Trigger on Shopify orders and call GraphQL

Start the flow with a Shopify trigger such as a new order. Activepieces, which carries 750 integrations in its MIT-licensed core, registers the webhook for you, so you skip building a receiving endpoint and verifying its signature.

Then add the Shopify action steps you need. For an endpoint the integration doesn't cover, add a custom HTTP request step and send the same token in the Shopify access-token header, with a GraphQL query in the body.

![Activepieces workflow builder with the Send HTTP request step selected, showing its configuration panel with HTTP method…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/58352882-31ce-42ab-9b0f-c4a0fe866a5c/deepseek-r1-vs-v3-for-business-ai-2026-guide-scr-ae99964b.webp)

Take from it that both branches authenticate identically, so you never need a second credential.

Write code instead when the job is a heavy bulk sync, where you want direct control over query cost and throttling.

Do the same when you're building a public app that other merchants install. Those need OAuth, review and scale that a flow tool isn't meant to carry.

## Frequently asked questions

### Is the Shopify API free to use?

Yes, Shopify doesn't charge per call or sell API access as a product. What you pay for is the store plan behind it, plus your own time, because access is gated by app type, scopes and cost-based rate limits.

The bootstrap version is a custom app on your own store, which costs nothing beyond the plan you already have.

### Do you need a paid plan to use the API?

Do you need a paid Shopify plan to use the API? Not to build and test. A development store lets you create apps and try queries without a paid plan.

To run against a live store, that store needs an active plan, and some capabilities and higher limits depend on which plan it is.

If you're a beginner, build on a development store first so mistakes cost you nothing.

### Should you use REST or GraphQL in 2026?

Should you use REST or GraphQL in 2026? Use GraphQL. **Shopify treats the REST Admin API as legacy** and expects new apps to be built on GraphQL, so learning REST now means learning something you'll have to migrate away from.

Newer features also tend to appear in GraphQL first, which means REST code can leave you waiting on capabilities your competitors already use.

### How do you get higher rate limits?

How do you get higher Shopify API rate limits? Mostly by spending your allowance more carefully, since limits are cost-based. Request only the fields you need, use bulk operations for large exports, and subscribe to webhooks instead of polling.

Stores on higher-tier plans, such as Plus, get more headroom, but upgrading a plan only to fix an inefficient query is an expensive way to avoid a rewrite.

### How often does Shopify change API versions?

How often does Shopify change API versions? On a regular, published schedule, and each version is supported for a limited window before it's retired.

Pin your calls to a specific version and put the upgrade on your calendar. If you don't, a request that works today can start behaving differently, or fail, once your pinned version ages out.

## Related reading

- [Shopify MCP Server: 2026 Setup Guide](https://www.activepieces.com/blog/shopify-mcp-server-2026-setup-guide)
- [Shopify Mailchimp Integration: Setup Guide (2026)](https://www.activepieces.com/blog/shopify-mailchimp-integration-setup-guide-2026)
- [Step by Step Guide: Automating Gmail Emails for New Shopify Customers](https://www.activepieces.com/blog/automating-gmail-emails-for-new-shopify-customers-guide)

## References

- [Zato](https://zato.io/docs/dev/shopify/rate-limits-and-backoff.html)
