Shopify Products API — Catalogue, Prices & Stock

Get any Shopify store's catalogue as data. Give this Actor a list of store domains — or a link to one collection — and get back one row per product: title, handle, SKU, price, compare-at price, what is in stock, every variant, every image, the tags, the vendor and the dates. Ask for one row per variant and each size, colour and SKU arrives on its own line.

No API key. No app to install in anyone's store. No store password, no partner account, no Admin API token. $0.50 per 1,000 products, proxy included, stores that are not on Shopify are free, and a run that returns nothing costs nothing at all.

Try it in 30 seconds

{
  "stores": [
    "https://www.allbirds.com",
    "colourpop.com"
  ],
  "maxProductsPerStore": 100
}

One full URL, one bare domain — both work, and so does a myshopify.com domain, a product page link, or a collection link like https://www.allbirds.com/collections/mens.

What comes back

{
  "ok": true,
  "rowType": "product",              // "product" | "variant" | "collection" | "diagnostic"

  "storeDomain": "www.allbirds.com", // the host that answered, after any redirect
  "storeUrl": "https://www.allbirds.com",
  "input": "https://www.allbirds.com",

  "productId": 7218356060240,
  "handle": "mens-strider-explore",
  "url": "https://www.allbirds.com/products/mens-strider-explore",
  "title": "Men's Strider Explore - Natural Black (Dark Grey Sole)",
  "vendor": "Allbirds",
  "productType": "Shoes",
  "tags": ["DNAM BRANDS", "YCRF_mens-trail-shoes", "allbirds::gender => mens"],

  "description": "From exploring urban landscapes to tackling the trails (or both), this active shoe is here for it all…",
  "descriptionHtml": null,           // set when includeDescriptionHtml is on

  "price": 130,                      // cheapest variant
  "priceMax": 130,                   // dearest variant
  "compareAtPrice": null,            // the "was" price on the same variant, when there is one
  "currency": "USD",                 // read from the storefront — the feed has none
  "available": false,                // is anything in stock

  "variantCount": 13,
  "variants": [
    { "id": 41334293889104, "title": "8", "sku": "A11768M080", "price": 130,
      "compareAtPrice": null, "available": false, "options": { "Size": "8" },
      "grams": 919, "position": 1, "imageSrc": null }
  ],
  "options": [{ "name": "Size", "position": 1, "values": ["8", "8.5", "9", "…"] }],
  "images": [{ "src": "https://cdn.shopify.com/s/files/1/1104/4168/files/A11768….png?v=1759336475",
               "alt": null, "width": 4000, "height": 4000, "position": 1 }],
  "imageUrl": "https://cdn.shopify.com/s/files/1/1104/4168/files/A11768….png?v=1759336475",

  "publishedAt": "2026-08-26T10:22:14-07:00",
  "createdAt": "2025-09-10T12:47:47-07:00",
  "updatedAt": "2026-09-09T07:23:04-07:00",

  "collection": null,                // the collection handle, when one was walked
  "position": 2,                     // 1-based, in the order this run read the store

  "error": null,
  "errorType": null,
  "scrapedAt": "2026-09-09T15:31:04.512Z",
  "source": "www.allbirds.com",
  "sourceUrl": "https://www.allbirds.com/products.json?limit=250&page=1"
}

With "rowPerVariant": true, the same product arrives as thirteen rows carrying the same columns, each with its own variantId, sku, price, available and option1–option3. With "includeCollections": true, the store's collections follow as rowType: "collection" rows with productsCount, handle and url — up to maxCollectionsPerStore, which defaults to 250 because a large shop can hold several thousand of them.

Use cases

• Competitor price and assortment tracking — run it daily, diff on productId and updatedAt, and you have every price move, every new drop and every discontinued line.
• Stock and sell-out monitoring — available per variant tells you which sizes sold out and when, which is the signal behind most resale and demand forecasting.
• Discount and promotion watching — compareAtPrice > price is a sale, per variant, with no guesswork about a badge on a page.
• Catalogue and feed building — a clean product feed for a marketplace, an affiliate site, a comparison engine, or a merchandising review, without asking each merchant for access.
• Dropshipping and sourcing research — vendor, product type, tags, weight and SKU across a list of suppliers in one schema.
• Retrieval for a shopping agent — one flat array of products with descriptions and prices, ready to embed or hand to a model.
• Brand and market mapping — feed a list of domains and let the diagnostic rows tell you which of them are Shopify stores at all.

How it works, and why it keeps working

Every Shopify store publishes its own catalogue as JSON at /products.json, and its collection list at /collections.json. Those endpoints are part of the storefront — the same data the shop's own theme reads — and they are open to anyone with the URL. This Actor reads them and nothing else. There is no browser, no rendering, no per-product page fetch, and no Admin API token: one request returns up to 250 whole products, variants, images and all.

Step	Request	What it gets
1	/products.json?limit=250&page=1	Up to 250 products — or the answer that this shop is not one
1b	/ (the storefront)	The store's currency, which the product feed does not publish
2…	/products.json?limit=250&page=N	The next 250, until your cap or the end of the catalogue
C	/collections.json?limit=250&page=N	The collection list, when includeCollections is on

Three details are where a naive version of this goes wrong, and all three came out of real captured responses:

• The end of a catalogue is not "a page smaller than limit." Asked for five products, one captured store answered with five through one proxy exit and three through another. A walker that stopped at "fewer than I asked for" would have read three products and called it a catalogue. So page one teaches the walk what this shop calls a full page, and every later page is measured against that. A shop that ignores page altogether is caught by remembering product IDs.
• A 404 is not an answer to "is this Shopify?". A store with its feed switched off — a headless storefront, a password-protected shop — answers exactly like a site that was never on Shopify. So the 404 body is inspected first, and only when it gives nothing away is the storefront read once and classified. You get products-disabled or not-shopify, not a shrug.
• www is not a different shop. Redirects settle most of it and are followed; when they do not, the other spelling of the host is tried. Whatever finally answers is the origin the rows name, so every url in your dataset is a link that opens.

Underneath: Apify proxy, one pinned session per parallel worker. When something in front of a shop refuses an exit IP — HTTP 403, HTTP 429, or a CDN block page wearing an HTTP 200 — that session is retired and the same page is asked for once more from a different address. Retrying on an address that was just refused only deepens the block, so it is never done. If the second address is refused too, the walk stops, keeps every product it already delivered, and files one free blocked row saying where it stopped.

Pages of the same store are spaced 250–600 ms apart. Nothing forces that; it is the difference between reading a catalogue and hammering a shop.

How it compares

• No app install, no store access. Nothing to add to a merchant's admin, no Admin API token, no partner account. It reads what the storefront already serves the public.
• One request per 250 products. Not one page fetch per product. That is why the price per product can be what it is.
• Variants are real rows, not a nested blob. Turn on rowPerVariant and every SKU is a line with its own price and stock, so a spreadsheet or a SQL table can hold it without a JSON parser.
• Failures are legible and free. Not on Shopify, feed switched off, blocked, empty, a typo in a domain — each is a diagnostic row with an errorType you can branch on, and no charge. A run that returns nothing at all finishes FAILED with the reason in its status message, never a green run containing an apology.
• A partial catalogue is kept, not thrown away. Hit maxRunSecs or your charge ceiling on page 9 and you keep pages 1–8.
• Prices are numbers. price, priceMax and compareAtPrice are floats in the store's own currency, not strings with a symbol glued on.

Input reference

Field	Type	Default	What it does
stores (required)	array of strings	prefilled with one store	Domains or URLs. Bare domains, full URLs, myshopify.com domains, product links and collection links all work. Duplicates are read, and billed, once
maxProductsPerStore	integer	250	Products per store. Also sets the page size, so asking for 100 downloads 100. 0 = the whole catalogue. Counts products, not rows, when rowPerVariant is on
rowPerVariant	boolean	false	One row per variant instead of one per product. Variant rows are billed like product rows
includeCollections	boolean	false	Also return the store's collections as their own rows, billed at $0.0005 each
maxCollectionsPerStore	integer	250	Collection rows per store, when collections are on. Also the page size. 0 = every collection the store has — which on a big catalogue can be thousands
collectionHandle	string	—	Read one collection from every store instead of the whole catalogue. Handle, path or full URL. A stores entry that names its own collection keeps it
includeDescriptionHtml	boolean	false	Add the raw description markup next to the plain text every row already has
includeImages	boolean	true	Fill in the images array. Off still keeps imageUrl. Nothing extra is fetched either way
onlyAvailable	boolean	false	Skip sold-out products, and sold-out variants. Skipped products do not count towards the cap
maxConcurrency	integer	3	Stores in parallel. Each worker keeps its own proxy session. Pages within one store are sequential
maxRunSecs	integer	240	Whole-run wall-clock budget. When it runs out the Actor keeps what it has and files a free diagnostic row for each store it never reached
proxyConfiguration	object	Apify datacenter	The cheap default, which most stores accept. Switch it to the RESIDENTIAL group for the brands that sit behind a bot filter

Output reference

Every row carries the same keys. ok: true is a product, a variant or a collection; ok: false is a free diagnostic row.

Field	What it is
rowType	product, variant, collection or diagnostic
storeDomain, storeUrl, input	The host that answered, its origin, and the entry you supplied
productId, handle, url, title	Shopify's ID, the URL slug, the public page, the name
vendor, productType, tags	The merchant's own brand, category and tags — often the only structured facts a shop publishes
description, descriptionHtml	The description as text (always) and as markup (opt-in)
price, priceMax, compareAtPrice, currency	Cheapest and dearest variant, the "was" price paired with price, and the store's currency
available, variantCount, variants	Whether anything is in stock, how many variants, and all of them
options, images, imageUrl	The option axes, every image, and the first one
variantId, variantTitle, sku, option1–3, grams, variantImageUrl	The variant, on rowPerVariant rows
collection, collectionId, productsCount	The collection walked, and the collection's own ID and size on collection rows
publishedAt, createdAt, updatedAt	The shop's own timestamps. updatedAt is the field to diff runs on
position	1-based, in the order this run read the store
ok, error, errorType	Whether this row is data, and if not, why not
scrapedAt, source, sourceUrl	When, and the exact feed page it came from

errorType on a diagnostic row is one of:

Value	Meaning	Charged?
not-shopify	The domain answers, but it is not a Shopify store	No
products-disabled	A Shopify store whose public product feed is switched off — headless, password-protected, or turned off by the merchant	No
blocked	Something in front of the store refused two different proxy exits. Products already returned for that store are kept	No
not-found	Nothing answered at that domain — a typo, a dead shop, or DNS	No
no-products	The catalogue (or the collection) is published and empty	No
invalid-input	The entry was not a domain or a URL	No
timeout	The run's maxRunSecs budget ran out before this store was reached	No

Pricing

$0.50 per 1,000 products. Pay-per-event, with the proxy already inside that number — there is no separate proxy line on your bill for this Actor.

Event	What triggers it	FREE	Starter	Scale	Business
Product returned (primary)	One product or variant row written to your dataset	$0.0005	$0.0005	$0.0004	$0.0003
Collection returned	One collection row, when you ask for them	$0.0005	$0.0005	$0.0005	$0.0005
Run started	Once per run, after the first product	$0.001	$0.001	$0.001	$0.001

Collections are billed per row too, at $0.0005 each. Shops keep many more collections than most people expect — several thousand on a large catalogue, most of them merchandising rules rather than anything a shopper browses — so includeCollections is off by default and maxCollectionsPerStore caps it at 250 when you turn it on. Raise it deliberately.

Worked example. 20 stores at 250 products each, of which 2 domains turn out not to be Shopify:

• 18 stores × 250 products × $0.0005 = $2.25
• 1 run start = $0.001
• 2 non-Shopify domains = $0.00
• Total: $2.251

What you are never charged for: a domain that is not a Shopify store, a store with its feed switched off, an empty catalogue, a blocked store, a typo, or a store the run never reached before maxRunSecs. If a whole run comes back empty it finishes FAILED and bills nothing at all, start fee included.

Set ACTOR_MAX_TOTAL_CHARGE_USD on a run and the Actor stops walking once the ceiling is in sight, rather than handing you rows it cannot bill or billing you for rows it cannot hand over. It finishes SUCCEEDED with the ceiling named in its status message, and everything already delivered is yours.

Limits, and the ones that might bite

Not every store publishes the feed. A merchant can switch /products.json off, and a headless store — one whose front end is built separately from Shopify — does not serve it at all. Those stores come back as free products-disabled rows. There is no other public endpoint that lists a store's catalogue, so this is a real limit rather than something a different tool solves quietly.

Some storefronts refuse datacenter addresses. Most large shops serve the feed to anyone, but a CDN rule in front of a storefront can refuse datacenter address ranges — sometimes only from certain exits, or only at certain times. When that happens you get free blocked rows rather than partial data, and switching proxyConfiguration to the RESIDENTIAL group is the fallback. That is why the proxy is a normal input and not a locked one.

Stock is the merchant's flag, not a warehouse count. available is Shopify's own boolean, which follows the shop's inventory policy: a store that lets customers buy past zero reports its products as available. There is no quantity in the public feed for any client, this one included.

Currency comes from the storefront, not the feed. Shopify's public product feed publishes prices as bare numbers with no currency anywhere in the payload, so the Actor reads the shop's front page once per store to get it. A shop whose front page could not be read leaves currency null and its prices in the store's own default currency.

Alt text is usually missing. The public feed's image objects carry src, width, height and position — and, on most stores, no alt text at all. The column is there and is filled when a store publishes one.

Only what is published. Draft products, products hidden from the online sales channel, and market- or customer-specific prices are not in the public feed. This Actor does not log in, does not accept a store password and does not take an API key belonging to anyone, and it never will — that is a deliberate line, not a missing feature.

Prices are the shop's default market. A store that shows different prices in different countries publishes its home-market prices here.

The upstream format may change. Shopify has served this feed in this shape for years, but it is a storefront endpoint and it can change without notice. When a shape changes, rows stop arriving and you get free products-disabled or not-shopify diagnostic rows rather than quietly wrong data, and a run that returns nothing bills nothing.

Rate and reliability. Requests go out through Apify proxy with per-worker sessions, one rotation per refusal, and a 250–600 ms pause between pages of the same store. Three stores in parallel is the default because it is where throughput and block rate balance; raising maxConcurrency speeds a long list up and makes blocks more likely.

Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with limited permissions, uses pay-per-event pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The Integrations tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

curl -X POST "https://api.apify.com/v2/acts/insight.solutions~shopify-products-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"stores":["allbirds.com"],"maxProductsPerStore":50,"onlyAvailable":true}'

# pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/shopify-products-api").call(run_input={
    "stores": ["https://www.allbirds.com/collections/mens"],
    "maxProductsPerStore": 0,
    "rowPerVariant": True,
    "onlyAvailable": True,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not row.get("ok"):
        print("skipped:", row["input"], row["errorType"])
        continue
    sale = row["compareAtPrice"] and row["compareAtPrice"] > row["price"]
    print(f'{row["title"]} / {row["variantTitle"]}  {row["price"]} {row["currency"] or ""}'
          f'{"  ON SALE" if sale else ""}')

Turn includeImages off when you only need the words and the numbers — the payload shrinks and the price is the same.

FAQ

Do I need permission from the store? The endpoint this reads is part of every Shopify storefront and is served to anyone who asks, the same as the shop's own product pages. No app install, no token, no store password. Whether the use you make of a catalogue is allowed is a separate question, and it is yours — see the notes at the bottom.

Why did my store come back as products-disabled? Either the merchant switched the public feed off, or the shop is headless — the front end is built separately and only the checkout is Shopify. Both are common on very large brands. There is no public endpoint that lists such a store's catalogue.

How do I get every product from a big store? Set maxProductsPerStore: 0 and raise maxRunSecs. Ten thousand products is 40 sequential requests with a short pause between each — plan for a minute or two, and bound it with ACTOR_MAX_TOTAL_CHARGE_USD if you are not sure how big the shop is.

Are variant rows charged? Yes, at the same rate as products — a variant row is a row. That is why rowPerVariant is off by default. variants[] on a product row carries the same information for one charge.

How fresh is it? Live. Every run reads the store at that moment; nothing is cached. scrapedAt is on every row, and updatedAt is the shop's own last-changed timestamp, which is what to diff between runs.

Can I get inventory quantities? No, and neither can any other public client: the storefront feed publishes a boolean, not a count.

Can I scrape one collection instead of the whole store? Yes — paste the collection URL into stores, or set collectionHandle to apply one handle across every store in the list.

What happens if one store fails? The others still run. The failed one produces a free diagnostic row and the run finishes SUCCEEDED. If every store fails, the run finishes FAILED and you are billed nothing at all.

Which proxy should I use? Start with the default datacenter proxy; it is what the price is built on and it works on the large brands we have measured. If a particular store comes back blocked, re-run that one with the RESIDENTIAL group — a refusal is usually about the exit address, not about the shop.

Legal and data-protection notes

• Public storefront data only. Every source is an endpoint the shop serves to any visitor. The Actor never logs in, never accepts cookies or a store password, never takes an API key belonging to anyone else, and never touches draft, unpublished or admin-only data.
• Product data is not personal data, but your use of it is regulated anyway. Catalogues, prices and stock are business information, and collecting them for price comparison, market research and competitor analysis is ordinary and long-established. Reselling a merchant's descriptions and photography verbatim is a different thing — the copy and the images belong to whoever made them.
• Respect the shop. This Actor paces itself, identifies as an ordinary client and never tries to get past a refusal more than once. Please do not defeat that by pointing a thousand parallel runs at one store.
• Not affiliated with Shopify Inc. or with any store, brand or merchant whose catalogue you retrieve. All product names and trademarks belong to their respective owners and are used only to describe which public endpoints this Actor reads.

Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

Video, audio & social

• YouTube Transcript API — captions as timed segments, text, SRT or VTT, with language fallback and translation.
• YouTube Comments API — comments and replies with likes, pinned and hearted flags, newest or top sort.
• YouTube Channel API — a channel's videos, Shorts and live streams, plus YouTube search.
• Podcast Search, Episodes & Charts API — Apple Podcasts search, charts and full episode feeds.
• Bluesky Scraper — profiles, posts, followers and follows from the public AT Protocol API.
• Telegram Channel Scraper — posts, views and channel stats from public Telegram channels.
• Substack Scraper — posts with full free text, comments and publication profiles.

News, documents & the web

• Google News Search, Topics & Real Article URLs — news search and topic feeds with the publisher's real URL decoded.
• Website to Markdown — Content Extractor for LLMs & RAG — any site as clean Markdown, text and heading-aware chunks.
• Internet Archive API — archive.org search, item metadata, files and reviews.
• Wayback Machine Toolkit — archived URL inventories, snapshots and text diffs between dates.
• Website Technology Detector — the tech stack behind any site, with the evidence for each detection.
• Domain Intelligence API — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
• SEO Page Audit — sitemap crawl with on-page checks, structured data and broken-link reports.
• Keyword Suggestions API — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
• Website Contact Extractor — emails, phone numbers and social profiles from any list of websites.

Business, finance & jobs

• Congress & Insider Trades API — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
• SEC EDGAR API — filings, XBRL financials and full-text search by ticker or CIK.
• Y Combinator Companies, Batches & Founders — the YC directory with founders and social links, filterable by batch, industry and hiring status.
• Career Site Jobs API — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
• New Job Postings Monitor — new, closed and changed postings on the career sites you watch.

Apps & games

• App Store & Google Play Reviews API — reviews from both stores with ratings, versions and developer replies.
• App Store Top Charts & App Search API — Apple top charts by country and genre, plus app search and details.
• Steam Reviews API — Steam reviews with playtime, helpfulness and game details.
• Steam Game Data API — prices, tags, review scores, live player counts and top charts.