Summarize with AI
Shopify connects to ERP, PIM, CRM and WMS systems through its APIs. Which APIs to use in 2026, how custom apps work in the Dev Dashboard, which plan limits matter, four ways to integrate and what we learned from integration projects for L'Occitane, Shoepassion and other brands.
Short answer: yes, Shopify has APIs, and they are how every serious integration works. An ERP, PIM, CRM, WMS or marketplace connects to Shopify through the GraphQL Admin API (products, orders, customers, inventory), listens for changes with webhooks, and, if you run a custom storefront, uses the Storefront API. What you can build depends on your plan, on how the app is created (in 2026: in the Dev Dashboard) and on API limits. This guide explains how it works, what changed since we first published it in 2021, and what we learned from 400+ Shopify and Shopify Plus projects, including ERP and PIM integrations for brands like L'Occitane and Shoepassion.
What is an API?
API stands for Application Programming Interface. The easiest way to picture it is a restaurant. The guests (your ERP, PIM or another app) never walk into the kitchen (Shopify). They order from a menu (the list of things the API allows), and a waiter (the API) takes the order to the kitchen and brings back the dish (data or a confirmation). The kitchen decides what is on the menu, and it can refuse orders that are too big or come too often.
That last part matters in practice. Shopify controls the menu: which data an app can read or write (access scopes), how fast it can ask (rate limits) and in which format (API versions). An integration can run one way (for example orders from Shopify to the ERP) or both ways (stock and prices from the ERP back to Shopify).
Shopify APIs in 2026: which one does what
Shopify's API documentation lists more than twenty APIs and tools. For connecting business systems, these are the ones you will actually meet:
| API | What it is for | Typical integration |
|---|---|---|
| GraphQL Admin API | Reading and writing store data: products, variants, inventory, orders, customers, B2B companies, metafields | ERP, PIM, WMS, CRM, marketplaces, reporting |
| Webhooks and Events | Notifications when something changes in the store (new order, stock update, refund) | Sending orders to the ERP or WMS as they happen |
| Bulk operations | Large asynchronous exports and imports in JSONL files | Full catalog sync from a PIM, nightly reconciliation |
| Storefront API and Customer Account API | Products, cart and customer accounts for custom storefronts | Headless (Hydrogen or another framework), mobile apps |
| Shopify Functions | Your own logic running inside Shopify: discounts, delivery, payment and cart rules | B2B pricing, VAT logic, shipping rules |
| Checkout, admin and POS UI extensions | Adding fields and blocks to checkout, the admin and Shopify POS | Pickup points, store stock in POS, data the ERP needs from checkout |
| Payments Apps API | Payment, capture, refund and void sessions for payment providers | Payment gateway apps built by payment partners |
| Partner API | Data of a Shopify Partner organization (transactions, payouts) | Agencies and app developers, not merchants |
AI agents and assistants also reach store data through these APIs, for example via Shopify's MCP servers. We explain that layer in Shopify MCP explained.
What changed since 2021
If you read older guides about the Shopify API (including the first version of this one), several things no longer apply:
- Private apps are gone. The old path "Apps > Manage private apps > Create a new private app", with an API key and password, no longer exists. Integrations are built as custom apps (for one store) or public apps (for the App Store). According to the Help Center, custom apps are created and managed in the Dev Dashboard; custom apps created in the Shopify admin before January 1, 2026 are "legacy custom apps" and can still be managed there.
- REST is legacy, GraphQL is the default. "The REST Admin API is a legacy API as of October 1, 2024", and since April 1, 2025 all new public apps must be built only with the GraphQL Admin API (shopify.dev). Many existing connectors still use REST, so ask any integration vendor which API they use and when they plan to move.
- The Ping API is no longer listed among Shopify's APIs.
- Scripts and checkout.liquid are retired. Custom checkout and cart logic now runs on Shopify Functions and checkout UI extensions. We cover what this means in our Checkout Extensibility guide.
- Bulk operations got faster. From API version 2026-01, each app can run up to five bulk query operations per shop at once (before: one), according to Shopify's documentation.
Four ways to integrate Shopify with another system
Not every integration needs a developer. In our projects we choose between four options, from the simplest to the most flexible:
| Option | When it fits | Watch out for |
|---|---|---|
| Ready-made app or connector (Shopify App Store or the system's vendor) | Popular systems with a maintained connector, standard data flows | Which fields it syncs, how often, what happens on errors, monthly cost |
| No-code automation: Shopify Flow, Zapier | Simple "if this, then that" rules, notifications, tags, internal tasks | Not built for syncing thousands of products or orders; Flow's Send HTTP request action needs Grow or higher |
| Middleware or integration platform (iPaaS, ESB, order management tools) | Several systems talking to each other, or a company-wide data bus already exists | One more system to pay for and maintain; who owns the data mapping |
| Custom app on Shopify's APIs | Non-standard processes, custom ERP, B2B rules, several stores to keep in sync | Needs maintenance: quarterly API versions, monitoring, documentation |
Shopify Flow is a free app on the Basic, Grow, Advanced and Plus plans and is often enough for simple automations. Zapier helps when the other system has no Shopify connector, but you only get the triggers and actions Zapier prepared. For anything that moves product, stock or order data at volume, we use a connector, middleware or a custom app.
How a custom API integration works, step by step
This is the order we follow when we connect an ERP or PIM through a custom app:
- Map the data first. For every field (price, stock, product description, customer, order status), decide which system is the source of truth and in which direction it flows. Most integration problems we fix later come from two systems both thinking they own the same field.
- Create the app in the Dev Dashboard and give it only the access scopes it needs (for example read orders, write inventory). Fewer scopes means less risk if a token leaks.
- Pin an API version. Shopify releases a new version every quarter (the latest stable one is 2026-10) and supports each for at least 12 months. If an app calls a version that is no longer available, Shopify "falls forward" to the oldest supported one, which can change responses without warning (API versioning). Plan an upgrade at least once a year.
- Use webhooks for changes, bulk operations for volume. Webhooks tell the ERP about a new order within seconds. Bulk operations move full catalogs. Shopify says webhook delivery isn't always guaranteed and ordering isn't guaranteed either, and recommends periodic reconciliation jobs (webhooks), so we always add a scheduled check that compares both systems.
- Respect the limits. The GraphQL Admin API uses a cost-based limit (see the table below), a single query can't cost more than 1,000 points, and pagination stops at 25,000 objects. Large catalogs go through bulk operations instead.
- Monitor and log. A failed sync should create an alert someone actually reads, not a silent error in a log file. The Dev Dashboard also flags apps that call deprecated APIs.
Plan limits that matter for integrations
Your Shopify plan decides how much data a custom app can reach and how fast:
| Limit | Basic | Grow | Advanced | Plus |
|---|---|---|---|---|
| Custom apps using Shopify APIs | Limited data access | Full data access | Full data access | Full data access |
| GraphQL Admin API rate limit | 100 points/s | 100 points/s | 200 points/s | 1,000 points/s |
| API limits on the pricing page | Standard | Standard | Up to 2x on select APIs | Up to 10x on select APIs |
| Shopify Flow: Send HTTP request | No | Yes | Yes | Yes |
| Headless storefronts | 1 | 1 | 1 | 25 |
Sources: Shopify pricing, GraphQL Admin API rate limits, Shopify Flow, checked October 28, 2026. Large catalogs hit one more limit: stores with 500,000 product variants can create only 10,000 new variants per day, which doesn't apply to Shopify Plus (API limits). If you are choosing a plan for integration reasons, compare them in our Shopify Plus vs Advanced guide and the Shopify pricing guide for 2026.
What we learned from integration projects
A few examples from our public case studies show how different a "Shopify API integration" can look:
- L'Occitane (8 markets moving to Shopify Plus): we built a custom app for data exchange between Cegid ERP, the client's ESB (enterprise service bus) and Shopify Plus, plus ERP and POS integrations with delivery, payment and invoicing providers for each market (case study). When a company already has a data bus, Shopify becomes one more system on it, not the center.
- Shoepassion: integration with the Pixi ERP and a PIM, and a custom app connected to Shopify POS that checks stock in each store in Germany and lets customers order shoe repair services (case study). For product data we often work with Plytix PIM; our podcast episode with Plytix's Trever Chidester covers PIM and DAM implementation.
- Eveline Cosmetics (several markets on one Shopify Plus instance): we integrated Shopify with BASE, which works as the hub between the store, the company's ERP and WMS and its marketplaces, and automates order processing (case study). With a ready hub in the middle, Eveline could add new sales channels without building separate infrastructure for each market.
- Bernstein: an app that validates EU VAT numbers in real time in the European Commission's VIES system, and Shopify Functions (Cart Transform) that show net prices to verified business customers (case study). This is the kind of B2B logic that needs the APIs; more in our Shopify B2B guide.
- The Odder Side: a custom app that keeps several Shopify Plus stores (one per market) in sync (case study).
- Przelewy24: we built the Przelewy24 payment app for Shopify in PHP on Symfony, to Shopify's requirements (case study). More on local payment methods in our Shopify Payments in Poland guide.
The common lesson: the API is rarely the hard part. The hard part is agreeing which system owns which data, what happens when a sync fails at 2 a.m., and who maintains the integration after launch.
Checklist before you start an integration
- Which systems need to talk to Shopify, and does each one have a maintained Shopify connector?
- For each data field: which system is the source of truth, and how fresh does it need to be (real time, hourly, daily)?
- How many products, variants and orders per day do you expect at peak (Black Friday, sales)?
- Does your plan give the app the data access and API limits it needs?
- Does the connector or app use the GraphQL Admin API and a supported API version?
- Who gets the alert when a sync fails, and how do you re-run it?
- Who owns the integration after launch: the vendor, your team or an agency?
Need help with a Shopify integration?
We are a Shopify Premier Partner, working with Shopify since 2016, with 400+ delivered projects. We connect Shopify with ERP systems, PIM and CRM, build custom Shopify apps and headless storefronts, and plan integrations as part of migrations to Shopify. See all our Shopify integration services or contact us and tell us which systems you need to connect.
