Shopify GraphQL Admin API. In 2026.
The REST deprecation path, how Shopify's GraphQL cost model actually works, query patterns that scale, and the 2026 API-version requirements every new app must ship with.
REST is over. Points are the rate limit.
Shopify's GraphQL Admin API has been the primary API since 2019 and is the only API path for new public apps since April 2024. Its cost model is points-based rather than the 2-calls-per-second REST model; every store has a 1000-point bucket that refills at 50 points per second (100 per second for Plus), with queries costing 1 to 50+ points depending on nesting depth. Well-designed apps execute 10 to 20 equivalent REST operations per second. Bulk operations handle large data jobs asynchronously without point cost. New apps in 2026 should target the latest stable API version (2026-04) and plan quarterly version bumps; existing REST apps should migrate endpoint-by-endpoint over 8 to 16 weeks rather than rewriting in a dedicated sprint.
REST is not gone. It is also not the path.
Shopify's official position on the Admin API is clear. GraphQL is the primary path. REST remains available for backwards compatibility but does not receive new features. New public apps submitted to the Shopify App Store after April 2024 must be GraphQL-first; the review team rejects submissions that rely on REST for core functionality. Existing REST-based apps continue to work, but every new Shopify feature ships with GraphQL-only support.
The features that exist only in GraphQL as of 2026: Shopify Functions (for checkout customizations, shipping logic, discount logic), Checkout Extensibility (post-checkout.liquid migration), Customer Account extensions, the B2B catalog APIs, Shopify Markets catalog pricing, bulk operations, and the metaobject API. A REST-only app in 2026 is functionally frozen; it can maintain what it has but cannot add any feature that depends on these capabilities. That is most net-new Shopify feature work since 2023.
The practical timeline for existing apps: if your app is REST-based and serves a public merchant base, plan a 12-to-18-month migration runway before Shopify's deprecation pressure escalates. Apps still on REST by late 2027 will start seeing feature-deprecation warnings and App Store feature limits. Apps on the latest GraphQL version are insulated from these pressures and can consume new Shopify features as they ship.
Points, not calls per second.
Shopify's REST rate limits were 2 calls per second for standard stores, 4 for Plus. Simple, predictable, easy to throttle against. GraphQL replaces that with a calculated-cost model where every query is priced based on the fields requested. A query for one product by ID: 1 point. A query for 50 orders with nested line items and customer data: 30 to 50 points. The per-store point bucket is 1000 points for standard stores, 2000 for Plus. The bucket refills at 50 points per second (100 for Plus).
The effect is a smarter rate limit. A well-designed GraphQL client that requests only the fields it needs can execute 10 to 20 equivalent REST operations per second within the same rate-limit budget. A poorly designed client that requests every field on every query can throttle itself faster than REST ever did. Shopify's rate limit docs explain the calculation; every response includes an extensions.cost object showing actualQueryCost, throttleStatus, and maximumAvailable points.
The operational hygiene: log the extensions.cost value on every production query. Queries that run hot (product search, order list, customer lookup) tend to accumulate cost faster than first-time developers expect. Tuning is straightforward once you see the numbers: remove fields you do not use, paginate aggressively, cache where the data is stable. A 30-point query running 100 times per minute is a 3000-point-per-minute app that is constantly bumping against the bucket ceiling.
Async beats pagination.
The best argument for GraphQL on Shopify is bulk operations. REST forced pagination for any large dataset: 10,000 products was 200 pages of 50, each a rate-limited API call, total runtime 100+ seconds at the REST rate limit. Bulk operations replace this with an async pattern. A bulk query initiates a job on Shopify's side; Shopify processes it in the background and writes results to a JSONL file on signed S3 storage. The client polls for completion and downloads the file when ready.
The cost math is favorable. A bulk query costs 1 point at submission and 0 points during processing. A REST pagination of 10,000 orders would consume roughly 4,500 points of the bucket over 100+ seconds; the same bulk query takes 1 point and runs in the background while the rest of your app continues at full rate-limit capacity. The latency tradeoff: bulk jobs take 30 seconds to 5 minutes to complete depending on volume, versus immediate (but throttled) REST pagination.
Use bulk operations for: catalog sync jobs, analytics extracts, daily reporting queries, migrations, and any one-time data pull above a few thousand records. Do not use them for user-facing queries where a 30-second delay is unacceptable; in those cases, paginate aggressively and cache at your application layer. The typical Shopify app has both: a bulk query for the overnight catalog sync, standard queries for user-facing interactions.
Quarterly bumps, 12-month support.
Shopify ships a new API version quarterly (January, April, July, October) and supports each version for 12 months from release. The latest stable in 2026 is 2026-04. A new app shipping in April 2026 should target 2026-04. An app targeting 2025-04 is on the last month of support and needs an immediate bump. An app targeting 2024-10 or older is already past end-of-support and may see features silently removed.
The discipline: pin your app to a specific API version in every query header, track Shopify's quarterly release notes, and schedule a version bump every 3 to 4 months. The bump itself is usually trivial if your queries do not rely on deprecated fields; Shopify's migration guides per version highlight breaking changes. The bump becomes painful when an app has accumulated 18+ months of drift because multiple breaking changes stack up.
The Shopify App Store review now enforces version currency. Apps submitted on a version older than "latest minus 2 quarters" are flagged in review; apps more than 18 months behind latest are rejected. For a public app this effectively mandates a 6-month version bump cadence. For a custom or custom-distribution app, the enforcement is lighter, but the features-available gap still matters.
Five mistakes that waste points.
One, over-fetching. GraphQL lets you request exactly the fields you need; most developers default to requesting everything because REST taught them to. On a 50-field product query, the difference between requesting 5 fields and 50 is a 5x cost multiplier. Audit every query against actual usage once every three months; fields that are not read by the consumer should be removed from the query.
Two, under-paginating. GraphQL connection-based pagination defaults to 50 items per page; pulling 500 in one query costs more than 10 pages of 50 due to how Shopify calculates connection costs. Always paginate in chunks of 50 to 250 for most resources. Use the pageInfo.hasNextPage + endCursor pattern, not fixed offsets.
Three, ignoring THROTTLED errors. Treating a rate-limit error as fatal and giving up wastes the recovery that Shopify's bucket refill provides. The correct pattern is to check extensions.cost.throttleStatus.currentlyAvailable on every response, calculate the time-to-refill, and sleep that long before retrying. A well-written client self-throttles and never sees a THROTTLED error in normal operation.
Four, not using bulk operations for large jobs. Shopify's point bucket is not sized for 100K-record pagination. A bulk query for that same data costs 1 point and runs in the background. The mental model shift is that "large jobs" now includes anything over 1,000 to 2,000 records; below that, pagination is fine, above, bulk. Mixing the two inside the same app is normal.
Five, not logging cost. Every GraphQL response includes extensions.cost.actualQueryCost showing the exact points consumed. Log this in production. Queries that are costing 2x to 5x more than expected indicate over-fetching or inefficient nesting; queries running at 80+ percent of bucket capacity indicate scheduling problems. The data is there for free; treat it like a production metric. For the broader Shopify app context, see the public vs custom app decision guide.
Six answers.
Is Shopify's REST Admin API actually deprecated?
Yes, with a clear timeline. Shopify announced REST deprecation for new public apps starting April 2024, which means apps submitted to the App Store after that date must be GraphQL-first. Existing REST-based apps continue to function for the foreseeable future, but new features are shipped GraphQL-first and REST parity lags by 6 to 18 months. By 2026 the gap is significant: Shopify Functions, Checkout Extensibility, Customer Account extensions, and bulk operations all have GraphQL APIs without REST equivalents. Any new Shopify app in 2026 should be 100 percent GraphQL; any maintained app should have a migration plan.
How does Shopify's GraphQL cost model work?
Shopify's GraphQL API uses a per-query cost system rather than the REST rate limits most developers are used to. Every query is priced in calculated points based on the fields requested: a simple product lookup might cost 1 point, a nested query pulling orders with line items and customers might cost 10 to 50 points. Every store has a 1000-point bucket that refills at 50 points per second (100 per second for Shopify Plus stores). Queries above the bucket size return THROTTLED errors; well-designed apps check the query-complexity before firing and batch with bulk operations for large jobs. Compared to REST's 2-call-per-second limit, a well-designed GraphQL client can execute 10 to 20 equivalent operations per second.
What are bulk operations and when should I use them?
Bulk operations are Shopify's GraphQL-only feature for large-scale data reads and writes. Instead of paginating 10,000 orders across 100 requests and watching the rate limit bucket, a bulk query initiates a single async job that Shopify runs on their side and delivers a JSONL file via a signed S3 URL. The cost: bulk queries are effectively free against the point bucket (one point at submission, zero during processing). The tradeoff: results are not immediate; expect 30 seconds to several minutes for the job to complete depending on the data volume. Use bulk operations for any one-time data migration, daily catalog sync, or analytics extract above a few thousand records.
What API version should my app target in 2026?
Shopify releases a new API version quarterly and maintains each version for 12 months. In 2026, the current stable versions are 2026-01 and 2026-04 with 2025-10 still supported and 2025-07 sunset. New apps should target the latest stable at submission time and plan quarterly version bumps. Features added in a newer version are not backportable; an app on 2025-10 cannot use 2026-04 features without bumping its API version. Shopify App Store review now requires apps to be within 2 versions of latest; an app on 2024-10 would fail review in April 2026 for being too old.
How do I migrate an existing REST app to GraphQL?
Incrementally. A full REST-to-GraphQL rewrite is expensive (6 to 12 weeks for a mid-complexity app) and risky (breaking merchants during migration). The safer path: wrap each REST endpoint in a GraphQL-equivalent function, migrate one endpoint at a time starting with the highest-traffic read paths, and leave writes for last. Use Shopify's GraphiQL explorer to validate each new query matches the REST output field-for-field. Most migrations take 8 to 16 weeks spread across normal development cycles rather than a dedicated sprint. Shopify publishes a REST-to-GraphQL mapping reference that covers the 90 percent case; the remaining 10 percent (complex filters, legacy fields) requires adaptation.
What are the common GraphQL mistakes on Shopify?
Five common mistakes. One, over-fetching: requesting every field on every query inflates cost unnecessarily; request only the fields you actually use. Two, under-paginating: the default page size is 50 for most connections; pulling 500 orders in one query costs more than pulling 10 pages of 50. Three, ignoring THROTTLED errors: treating them as fatal instead of retrying with backoff wastes the rate-limit recovery. Four, not using bulk operations for large jobs: paginating through 100K products hits the rate limit badly when a single bulk query would run in the background for free. Five, not checking extensions.cost on responses: Shopify returns the actual query cost in the response; log it and tune queries that run hot in production.
APIs are craft.
Our Shopify app development engagements cover GraphQL-first builds, REST-to-GraphQL migrations, and cost-model optimization. Scoped quote in 48 hours.