App Store Connect API
Changing prices with the App Store Connect API
Everything the pricing screens in App Store Connect do is available over the API. This is the map: which resources exist, what the requests look like, how many calls a worldwide change takes, and what goes wrong in practice.
The short answer
To change a price with the App Store Connect API, fetch the product’s price points for your base territory, pick the point for the new price, then create a price schedule: POST /v1/appPriceSchedules for apps, POST /v1/inAppPurchasePriceSchedules for in-app purchases, or one POST /v1/subscriptionPrices per territory for subscriptions. Authenticate with a JWT signed by a team API key.
Authentication
Every request carries a bearer JWT you sign with your API key’s .p8 private key (Apple: generating tokens):
- Header:
alg=ES256,kid= your Key ID,typ=JWT. - Payload:
iss= your Issuer ID,iat= now,exp= at most 20 minutes later,aud=appstoreconnect-v1. An optionalscopecan restrict a token to listed GET requests. - Reuse one token for many requests until it expires; Apple recommends this for performance. Long jobs mint a fresh token periodically.
- The key needs a role that can manage pricing: Admin or App Manager (Apple’s help pages list Account Holder, Admin or App Manager as the required role). Creating one is covered in the API key guide.
The resources
| Product | Price points | Equalizations | Create a price change |
|---|---|---|---|
| App | `GET /v1/apps/{id}/appPricePoints`?filter[territory]=USA | `GET /v3/appPricePoints/{id}/equalizations` | `POST /v1/appPriceSchedules` — base territory plus manual prices |
| In-app purchase | `GET /v2/inAppPurchases/{id}/pricePoints` | `GET /v1/inAppPurchasePricePoints/{id}/equalizations` | `POST /v1/inAppPurchasePriceSchedules` — base territory required |
| Subscription | `GET /v1/subscriptions/{id}/pricePoints` — always with filter[territory] | `GET /v1/subscriptionPricePoints/{id}/equalizations` | `POST /v1/subscriptionPrices` — one per territory |
| Territories | `GET /v1/territories` | — | Read-only: the 175 storefronts and their currencies |
Each price point has a customerPrice and your proceeds. The equalizations of a point are the matching points in every other storefront — Apple’s worldwide prices for that base price, with no exchange-rate math on your side. For subscriptions with monthly and up-front plan types, Apple also documents adjustedEqualizations (Apple: configuring subscription prices across territories). Read the current state with GET /v1/apps/{id}/appPriceSchedule and, for subscriptions, GET /v1/subscriptions/{id}/prices.
What the requests look like
An app price schedule is one JSON:API document with inline-created prices. The parts that matter:
| Where | Field | Value |
|---|---|---|
data | type | appPriceSchedules |
data.relationships | app | Your app’s ID |
data.relationships | baseTerritory | For example USA |
data.relationships | manualPrices | References to the prices in included, with temporary IDs like ${price-1} |
included[] | type | appPrices (in-app purchases: inAppPurchasePrices) |
included[].attributes | startDate, endDate | null for “now” and “open-ended”, or a date |
included[].relationships | appPricePoint | The price point ID for that territory |
Territories without a manual price get Apple’s automatic price derived from the base. A subscription price is simpler: type subscriptionPrices, attributes startDate and preserveCurrentPrice (plus planType where you offer plan types), and relationships to the subscription, the territory and the subscriptionPricePoint.
A worldwide change, step by step
- List territories once and cache them; they rarely change.
- For each product, fetch the price points in your base territory (200 per page) and find the one matching your new base price.
- For Apple’s pricing everywhere, stop there: the base point alone is enough for apps and in-app purchases. For your own regional prices, compute a target per storefront and snap it — the easy way is to snap the target in the base currency and follow that point’s equalizations (how snapping works).
- Apps and in-app purchases: POST one schedule with the base territory and every manual price. Subscriptions: POST one
subscriptionPricesper storefront, with the start date and the existing-subscriber policy. - Handle 429s and 5xx with backoff and retry; log every created resource as your audit trail.
- Read the schedule or prices back and spot-check a few storefronts in App Store Connect.
How many requests does it take?
A worked example: 2 apps, 10 in-app purchases and 4 subscriptions, repriced with 4 regional tiers. Apple’s rate-limit example shows 3,500 requests per rolling hour per key, and says actual limits vary — read the X-Rate-Limit header on every response (Apple: rate limits).
| Step | Calculation | Requests |
|---|---|---|
| Territories | Once | 1 |
| Base price points | 16 products × about 5 pages | ≈ 80 |
| Equalizations | 16 products × 4 tier points | ≈ 64 |
| App and IAP schedules | 12 products × 1 | 12 |
| Subscription prices | 4 subscriptions × 175 storefronts | 700 |
| Total | ≈ 857 |
Subscriptions dominate: Apple notes there is no bulk endpoint for applying equalized subscription prices. Double the catalogue, add retries and a verification pass, and you are close to the example hourly limit — so pace the job instead of firing a tight loop.
Gotchas
- A schedule POST replaces the whole app or in-app purchase schedule. Include every manual price you want to keep, not only the ones that change — anything left out falls back to Apple’s automatic price.
- To schedule a future change on an app or IAP, send today’s manual prices with an
endDateequal to the newstartDate, followed by the new prices. Two adjacent intervals at the same price point are rejected (“Adjacent intervals cannot have the same price point”), so send an unchanged territory as one open-ended entry. - Subscriptions keep at most one future price per territory. Delete the queued one with `DELETE /v1/subscriptionPrices/{id}` before creating another.
- A subscription price with no start date is the initial price. Once the subscription is approved, further prices need a
startDate; otherwise the API answers with a 409 state error. - Subscription decreases apply to existing subscribers, and any subscription change cannot be reverted once in effect. Increases may need consent — see raising a subscription price.
- Price-point lists are large. Always filter by territory, and paginate.
- Tokens live at most 20 minutes for these endpoints; long jobs must re-sign.
- Changes can take up to an hour to show in the sandbox.
- Nothing in the API asks “are you sure?”. Build the review step yourself.
Testing a pricing script safely
There is no staging copy of your App Store Connect account, so build safety into the script itself:
- Give the script a dry-run flag that computes everything and prints a table of product, territory, current price and new price — and sends nothing.
- Before writing, read the live schedule or prices and diff them against your plan; skip territories that already have the target price.
- Run the first real write on one product that is not on sale yet, or on a single territory, and read it back.
- Write a log line per territory with the old and new price point. If something goes wrong, that log is how you put prices back.
- Keep the key in a secret store, never in the repository, and give the script its own key so you can revoke it independently.
Skip the script: RepriceCat
RepriceCat is, in effect, this guide as a product. You connect your own team key (stored encrypted, revocable any time), and it fetches price points, snaps tier prices to valid points, builds the schedules — including the carry-over of today’s prices for scheduled changes — and paces itself against the rate limit.
- A review table of product × country, today’s price → new price, before anything is sent; a dry run that sends nothing.
- Up to 200 products across apps in one change, now or on a date.
- Failed countries listed with Apple’s reason and re-sendable alone; every change logged per country with rollback.
- Spreadsheet round trip: export prices to XLSX or CSV, edit, import back.
Weighing build versus buy? Read RepriceCat vs API scripts, or start with a free month.
Frequently asked
Which role does an App Store Connect API key need to change prices?
Admin or App Manager. Apple’s pricing help pages list Account Holder, Admin or App Manager as the roles that can manage prices; keys with Developer, Marketing, Sales or Finance roles cannot.
Can the API change prices for all territories in one request?
For apps and in-app purchases, yes: one price schedule carries the base territory and every manual price. For subscriptions each territory is its own subscriptionPrices resource, so a worldwide change is up to 175 requests per subscription.
How do I get Apple’s equalized prices through the API?
Find the price point for your base price, then call its equalizations endpoint. It returns the comparable price point in every other storefront, which you can use as-is or as the snapped price for a regional tier.
Is there a sandbox or dry-run mode for pricing calls?
No. Price schedules act on the real account. Review the computed batch carefully, test on a product that is not live yet, or use a tool with its own dry run.
What is the App Store Connect API rate limit?
Limits are per API key over a rolling hour and are reported in the X-Rate-Limit header of every response. Apple’s example shows 3,500 requests per hour but says actual limits vary; exceeding it returns HTTP 429.
How do I cancel a scheduled price change through the API?
For a subscription, delete the pending subscriptionPrices resource. For an app or in-app purchase, post a new schedule without the future entry, remembering that the POST replaces the whole schedule.
Try it
Reprice every territory from one base price
Tiers, price-point snapping, one review table, one confirmation — through the App Store Connect API. First month free, then $1 per app per month.