# Amazon Product Specs: Weight, Dimensions, GTIN & Model (`amazonscrapers/amazon-product-specs`) Actor Get the physical facts of Amazon products: weight, box dimensions, model number, part number, GTIN or EAN, colour, material, country of origin, warranty and the full merged specification table. 19 marketplaces, and it works where prices do not. - **URL**: https://apify.com/amazonscrapers/amazon-product-specs.md - **Developed by:** [Amazon Scrapers](https://apify.com/amazonscrapers) (community) - **Categories:** E-commerce - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.00 / 1,000 products with a specification tables This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Amazon product specs scraper: weight, dimensions, GTIN, model and materials Give it a list of products. Get back the specification table Amazon prints, taken apart into named fields: weight, dimensions, model number, part number, GTIN, colour, material, country of origin, warranty, and the whole raw table alongside. This is the boring half of a product catalogue and the half that decides what shipping costs. It is also the half Amazon is worst at presenting: the same fact lives under six different labels depending on which page variant you land on, and in at least three different tables. Twenty-two fields per product, nineteen marketplaces, and no dependence on the buy box, so this Actor works on marketplaces where the price ones return nothing. ### Why specifications are hard, and what this Actor does about it Amazon has eight different detail tables. Which ones a page carries depends on the category, the seller, and which layout you happened to be served. Measured 2026-08-24: five products in a row carried the product overview table with Color and Power Source, and none of them carried the technical table with Item Weight and Manufacturer. A scraper that reads one table goes quiet whenever Amazon picks the other. This one reads all eight and merges them, then reads the bullet-list layout as well, because on some pages the same facts are a list rather than a table. Then it maps the labels. Amazon writes weight as "Item Weight", "Product Weight", "Weight", "Artikelgewicht" or "Poids" depending on where you are. It writes the part number as "Manufacturer Part Number", "Item Part Number" or "Mfr Part Number". Each named field in the output collects all of those spellings, so `weight` is filled whichever one your page used. Getting that right is ongoing work rather than a solved problem. On 26 August 2026 three fields were still coming back empty on every product, and all three turned out to be our fault rather than Amazon's: `manufacturer` was being dropped on purpose by a filter that existed for a different reason, and `partNumber` and `warranty` were missing the exact labels Amazon uses. Fixed and measured the same day. The raw `specifications` object is in the output precisely so you can catch the next one yourself. ### Every field it returns Twenty-two per product: eleven named facts, the raw table they were pulled from, and enough identity to match the row against your own catalogue. #### Identity and catalogue | Field | What it holds | | --- | --- | | `asin` | The product id | | `title` | Full product title, shortened only past 1000 characters | | `brand` | Brand name | | `manufacturer` | Manufacturer, when different from brand | | `modelNumber` | Model number | | `partNumber` | Manufacturer part number | | `gtin` | GTIN, EAN or UPC | | `marketplace` | Which shop this row came from | | `url` | The page this was read from | | `scrapedAt` | Timestamp of the read | #### Specifications, pulled apart | Field | What it holds | | --- | --- | | `specifications` | Every row of every detail table, merged **(this is what you are charged for)** | | `productFacts` | Amazon's newer facts panel | | `weight` | Weight with its unit | | `dimensions` | Package or product dimensions | | `colour` | Colour | | `material` | Material | | `unitCount` | How many units in the pack | | `firstAvailable` | Date first available on Amazon | | `countryOfOrigin` | Country of origin | | `warranty` | Warranty description | | `importantInformation` | Safety and legal text, when present | | `isClimatePledgeFriendly` | The Climate Pledge Friendly badge | ### What it charges for This Actor charges on the specification table, not on the weight. That is worth explaining, because the first version did charge on weight and it was the wrong unit. Measured on twelve products: a weight on five of them, a specification table on ten. So on half the work this Actor did, it delivered twenty facts about a product and billed nothing, while paying for the page anyway. It is also the more honest unit. This Actor is called Product Specs and what it sells is the specification set. A product with twenty specifications and no weight is a complete answer, not a miss. A product with no specification table at all is the miss, and that is the row you do not pay for. Measured across a sixty product run: fifty-five of sixty carried a specification table, so roughly one row in twelve arrived free. ### A real row ``` asin B0CP9YB3Q4 title STANLEY Quencher H2.0 Tumbler with Handle and Straw 30 oz brand STANLEY manufacturer Stanley modelNumber 10-13425-020 partNumber 10-13425-020 gtin 00041604414831 weight 1.1 pounds dimensions 3.85 x 3.85 x 11.25 inches colour Rose Quartz material Stainless Steel unitCount 1 countryOfOrigin null warranty limited 5 year manufacturer warranty firstAvailable null specifications 14 rows, including Capacity, Included Components, Age Range Description, Item Type Name, Set Name isClimatePledgeFriendly false ``` Fourteen specification rows on that product, of which eleven map onto named fields. `countryOfOrigin` is empty because Amazon did not print it there, not because the read failed, and you can confirm that yourself by looking at the raw `specifications` object in the same row. ### What is often empty, and why Being straight about this is more useful than a longer field list. `countryOfOrigin`, `material` and `unitCount` depend entirely on the category. Measured across eight varied products on 26 August 2026: material on six of eight, both of the others on one. Electronics rarely carry any of the three; kitchenware and clothing usually carry material. `importantInformation` only appears on products with safety or legal text, which is mostly food, supplements, batteries and anything with a plug. `firstAvailable` and `warranty` show up on maybe one product in five. `gtin` is there when the seller supplied it, which for brand-name products is often and for white-label products is rarely. None of these emptinesses cost you anything: the charge is on the specification table, and a row with a table and no country of origin is a charged row that told you what Amazon knows. ### What to put in **ASINs or product URLs.** Paste them in any shape: a bare `B08N5WRWNW`, a full URL with tracking parameters, a spreadsheet cell that still says `ASIN: B08N5WRWNW`. Duplicates are removed across everything you give it. **A category or bestseller link**, to pull specifications for a whole category at once. **A search term**, when the catalogue you want is defined by what shoppers search for. ### Settings worth knowing about | Setting | What it does | | --- | --- | | `marketplace` | One of nineteen. Labels are read in the shop's own language, so a German page filling "Artikelgewicht" still fills `weight`. | | `proxyCountry` | Leave empty and it follows the marketplace. | | `maxItems` | Hard ceiling on delivered products. Zero means no ceiling. | | `maxItemsPerList` | How many products to take from each search term or category link. | | `maxListPages` | How deep to walk each list. | | `lanes` | How many products are read at once. Eight by default. Specifications do not come from the buy box, so pushing to sixteen costs less here than on the price Actors. | | `maxAttempts` | Attempts per product, each from a different address. Twelve by default. | | `residentialFallback` | Off by default. Measured 2026-08-26: on it cost roughly six times as much and returned two more products out of sixty. | | `economical` | Leave it off. The detail tables sit at the bottom of the page, so hanging up early is exactly how you lose the field you came for. | ### How it works, in plain terms Amazon refuses roughly six requests in ten to an address it has not seen before. Every product here gets up to twelve attempts, each from a different exit address, and the same address is never used twice in a row. Addresses that work are remembered for the rest of the run and tried first. The pace adapts: when refusals climb the runner slows down instead of pushing harder. Anything still refused at the end goes into a second pass at half speed, using only the addresses that already proved themselves. The retry rule follows the specification table rather than the price. That distinction cost real money to learn: an earlier version judged every Actor on whether a price had arrived, so this one burned twelve attempts on pages that had already handed over twenty specifications, and then charged for none of them. ### Reading the run log ``` Done: 15 charged (+5 delivered without a price, free), 0 refused by Amazon, 0 other. 359 KB per charged result, 69 attempts in total. Exit addresses: 39 used, 4 proven good, 10 burned. Attempts by outcome: {"refused by Amazon":44,"ok":20,"http_500":3,"proxy error":1,"network error":1} ``` `charged` is products that came back with a specification table. The bracketed number arrived complete without one and cost you nothing. If a run ever delivers rows and charges for none of them, the log says so in capitals at the bottom. ### Reliability, measured Three consecutive runs of twelve products on 26 August 2026, at the default settings: ``` run 1 12 of 12 delivered, 12 with a specification table run 2 12 of 12 delivered, 12 with a specification table run 3 12 of 12 delivered, 12 with a specification table ``` And one run of sixty products the same day: 60 delivered, 55 with a specification table, in 6.3 minutes. Worth reading out of that: nothing was lost at either size. 36 of 36 on the short runs and 60 of 60 on the long one. That is the shape you want before you schedule something, because a scraper that is reliable only on small batches is not reliable, it is lucky. The second is the residential switch, and the honest version is less dramatic than it sounds. Measured 26 August on the same sixty products, twice: with the switch off, fifty-one came back with the field this Actor charges on, for $0.0205 of platform usage. With it on, fifty-three came back, for $0.1192. Two more products for roughly six times the cost. That is why it is off by default. It is in your input form, so if a marketplace is refusing almost everything you can turn it on and pay for the difference. ### What you can build with it **A shipping cost model.** `weight` and `dimensions` across your catalogue, which is what every freight quote actually asks for. **A catalogue match.** `gtin`, `partNumber` and `modelNumber` are how you line an Amazon listing up against your own product records or a supplier's. **A compliance sweep.** `countryOfOrigin` and `importantInformation` where you need them for customs or labelling. **A sourcing brief.** `material`, `unitCount` and `dimensions` are what you hand a manufacturer when you want the same thing made. **A listing quality audit.** Count how many specification rows your own listings carry against the category leaders. A thin table is a conversion problem you can fix in an afternoon. ### Working it into your stack Every run writes to a dataset you can download as CSV, JSON, Excel or XML, or pull through the API. One shape note: `specifications` and `productFacts` are objects with whatever keys Amazon used, so a strict flat export will either drop them or stringify them. The eleven named fields exist so you do not have to deal with that for the common cases; keep the raw object when you need the rest. Schedules take a cron expression. Specifications change rarely, so weekly or monthly is usually enough, which makes this one of the cheapest Actors here to keep running. ### Marketplaces Nineteen, from amazon.com to amazon.co.jp, and labels are matched in the shop's own language rather than translated afterwards. Because none of this comes from the buy box, this Actor works where the price ones do not. Measured on amazon.de, where no product in the run returned a price: twenty specifications per product came back on eight of eight. If you are cataloguing a European marketplace, this is the Actor in the family that will actually give you something. ### Pricing Four dollars per thousand products with a specification table, plus three cents to start a run. Cataloguing a hundred products costs forty-three cents: a hundred times four tenths of a cent, plus the three cent start fee. You are not charged for a product with no specification table, or for one that never arrived, and platform usage is included. ### The rest of this family Eleven Actors on one engine. Around a specification scraper the useful ones are: - **Amazon Variants Scraper** when a listing turns out to be fourteen products and you need the specification set for each. - **Amazon Product Scraper** when you want all sixty-four fields, including price, rank and images, rather than the catalogue half. - **Amazon Bestsellers Scraper** to build the product list before you catalogue it. - **Amazon BSR Tracker** which, like this one, works on marketplaces where the buy box does not arrive. ### Questions people ask **Why is weight sometimes empty when specifications is not.** Because Amazon did not print a weight on that page. Look in the raw `specifications` object in the same row and you will see exactly what it did print. **Are the units normalised.** No. `weight` comes back as Amazon wrote it, "1.1 pounds" or "500 g". Converting would mean guessing at ambiguous cases, and the raw string is auditable in a way a converted number is not. **Can I get specifications for every variant of a product.** Feed the sibling ASINs in as input. The variants Actor in this family returns that list. **Why is manufacturer sometimes the same as brand.** Because Amazon printed the same value in both rows. It differs on products made under licence or by a contract manufacturer, which is exactly when you care. **How often should I run it.** Specifications rarely change. Once when you add a product, then monthly if you want to catch relabelling. **How many products can it handle.** No built-in ceiling. Sixty products took 6.3 minutes on the measured run, so a hundred is around 10. ### What it does not collect No review text, no reviewer names, no customer questions, no seller names. Those are personal data, and scraping them out of a public website is almost always a GDPR problem in Europe regardless of how public the page is. ### Legal note This Actor reads public pages and takes product facts: weights, dimensions, identifiers, materials. Business information about an item, not information about a person. You are responsible for what you do with the output. Check Amazon's terms for your own use case. # Actor input Schema ## `productUrls` (type: `array`): Amazon product URLs or bare ASINs, one per line. Leave empty if you are using Search instead. Duplicates are removed so you are never charged twice. ## `search` (type: `array`): Anything that lists products: a plain search term ("tower fan"), an Amazon search URL, a category link, or a bestsellers page. Each one is crawled and every product found is scraped. Use this when you do not know the ASINs up front. ## `marketplace` (type: `string`): Which Amazon site to read. The currency of the price follows the marketplace and the proxy country. ## `proxyCountry` (type: `string`): Which country the requests should appear to come from. Leave empty and it follows the marketplace: amazon.de is read from Germany, amazon.co.uk from the UK. This matters more than it looks -- Amazon shows different prices, currencies and even availability depending on where you appear to be. ## `maxItems` (type: `integer`): Hard ceiling on delivered products. 0 means no ceiling: the Actor keeps going until the lists run out or your limits stop it. ## `maxItemsPerList` (type: `integer`): Products to take from each search term or category link. Up to 10000. ## `proxyConfiguration` (type: `object`): Datacenter proxies were enough in testing: 30 out of 30 products returned with zero blocks. They are the cheaper option and the default. Switch to residential if you start seeing blocked pages at higher volume. Running without any proxy stops after roughly 85-120 products, because Amazon closes the door on a single IP address for over an hour. ## `lanes` (type: `integer`): How many products to read at the same time. Each lane uses its own exit address, so more lanes never means asking one address more often. Eight is the tested default and the most accurate. Sixteen finishes the same sixty products in about half the time, but measured on 2026-08-24 it returned six more products without a price, because Amazon strips the buy box sooner under pressure. Raise it when speed matters more than the last few prices. ## `maxAttempts` (type: `integer`): How often to retry a product Amazon refuses, each time from a different exit IP. A refusal is a property of one address, not of the product, and a refused attempt costs about 4 KB. Twelve tries is cheap insurance against a run that comes back short. ## `residentialFallback` (type: `boolean`): After half the attempts have failed, retry through residential addresses instead of datacenter ones. Measured 2026-08-26: residential transfer was 90 percent of the bill on a sixty product run ($0.150 of $0.167) while a run that never touched it delivered all sixty anyway. Leave it off unless you are losing products; turn it on when a marketplace refuses everything. ## `economical` (type: `boolean`): Hang up on each product page once the price is in, instead of reading it to the end. Roughly three times less traffic and about three times faster. Measured cost: over 30 products this lost 2 ratings, 4 review counts and 1 brand, because Amazon sometimes puts the rating below the price. Prices were identical either way. Leave this off unless you only need prices and are paying per gigabyte. ## `maxListPages` (type: `integer`): Result pages to walk per list. Up to 100. Amazon itself stops earlier on most searches. ## `minDelayMs` (type: `integer`): Pause between products. Measured 2026-08-23: at 1-2 seconds this returned 10 of 15 products; at 8-15 seconds it returned 12 of 15 on the same list. Pace turned out to matter more than anything else. The market leader waits about 14 seconds per product. ## `maxDelayMs` (type: `integer`): Upper bound for the pause between products. The actual pause is random between the minimum and this value, which looks less mechanical than a fixed interval. ## `retryPauseMs` (type: `integer`): How long to wait before trying a refused product again. Kept short because the retry already switches to a different exit IP, and waiting longer only makes the run more expensive. ## Actor input object example ```json { "productUrls": [ "B00FXNABPI", "https://www.amazon.com/dp/B0DXXYS4BJ" ], "search": [], "marketplace": "com", "maxItems": 0, "maxItemsPerList": 50, "proxyConfiguration": { "useApifyProxy": true }, "lanes": 8, "maxAttempts": 12, "residentialFallback": false, "economical": false, "maxListPages": 5, "minDelayMs": 8000, "maxDelayMs": 15000, "retryPauseMs": 300 } ``` # Actor output Schema ## `products` (type: `string`): One row per product with the physical and identity facts, plus the full merged specification table. Rows without a weight are delivered and never charged for. ## `summary` (type: `string`): Counts per outcome, exit addresses used, bytes per charged result. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "productUrls": [ "B00FXNABPI", "https://www.amazon.com/dp/B0DXXYS4BJ" ], "search": [] }; // Run the Actor and wait for it to finish const run = await client.actor("amazonscrapers/amazon-product-specs").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "productUrls": [ "B00FXNABPI", "https://www.amazon.com/dp/B0DXXYS4BJ", ], "search": [], } # Run the Actor and wait for it to finish run = client.actor("amazonscrapers/amazon-product-specs").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "productUrls": [ "B00FXNABPI", "https://www.amazon.com/dp/B0DXXYS4BJ" ], "search": [] }' | apify call amazonscrapers/amazon-product-specs --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,amazonscrapers/amazon-product-specs" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/gmZZTdZQwDG4UKpzY/builds/KlRZJaeoj2bkvdtlY/openapi.json