Run everything you never had time to implement. Define your process once, and keep it running with Qore.

All reports
Amazon Seller Central
Catalog & Listings

Amazon Listings Items Report (Listings Items API)

The Amazon Listings Items report is your own listing record for every SKU in a marketplace, pulled through the Listings Items API's searchListingsItems operation rather than as a Reports API file. For each SKU it gives you the summary (ASIN, product type, condition, status, FNSKU, title, created and updated dates, main image), every product-type attribute exploded one row per element, the open listing issues with their severity and enforcement actions, the current offer price, and the fulfilment channel with its merchant-fulfilled quantity. It is a snapshot of the listings as they stand on the day of the pull, not a history.

Known upstream as
searchListingsItems
One row is
One row per listing
Refreshed
Point-in-time snapshot
Columns
41
Marketplaces
All marketplaces
History
None inside the file. Every pull is the current state of your listings, stamped with the snapshot date and carrying no date range, and issues, offers and quantities mutate in place, so the only history that exists is the run of daily snapshots you have kept yourself.
Latency
The data is answered live by a synchronous endpoint, so a pull reflects your listings at the moment of the call. Amazon states that freshness for the per-SKU read rather than for this operation: its Listings APIs FAQ says getListingItem "directly queries the current state, which is why the results are available faster (within 1-5 minutes)", against the 0-15 minutes its listings notification pipeline can run behind. searchListingsItems answers the same item resource, so the figure is carried across operations rather than published for this one. One section is older than the rest by design — the attributes section shows the last data the selling partner submitted, while the live sections, such as fulfillmentAvailability, show the current state.
Requires

What this report contains

This is your own listing record for every SKU you sell in a marketplace, as Amazon holds it on the day you ask. It is not a Reports API file: it comes from the Listings Items API, one item resource per SKU, and that resource answers five sections at once, so the file lands as five tables joined on sku. There is no parent table, because the item itself has nothing beyond its SKU.

Summaries is one row per SKU per requested marketplace, strictly one per item on every validated pull. It carries the identity of the listing: asin, product_type, condition_type, status, fn_sku, item_name, created_date, last_updated_date, and the main image as main_image_link with its main_image_height and main_image_width.

Attributes explodes the product-type attribute blob one row per element. Attributes are an open vocabulary — 101 distinct names across one seller's 723 items, each value a list of product-type-specific objects, 26,056 elements in all — so no fixed set of columns can hold them. Each row is attribute_name, the element's attribute_index, the reported_marketplace_id and language_tag most elements carry, the scalar value where the element has one (about two thirds did), and the whole element as canonical JSON in value_json, which is the lossless copy.

Issues is one row per open listing issue, zero to three per validated item: code, message, severity, the affected attribute_names, categories and enforcement_actions (each comma-joined), and exemption_status with exemption_expiry_date. Offers is zero or one row per item with offer_type, price, price_currency_code, audience and audience_display_name. Fulfillment availability is zero or one row per item with fulfillment_channel_code and, on merchant-fulfilled channels only, quantity.

Everything is current state and mutates in place: issues appear and resolve, offers reprice, quantities move. There is no date range on any row, only the snapshot date the pull was made. The sample on this page joins the summaries, offers and fulfillment availability tables on sku into one view; the file itself keeps them apart.

How to get it

There is no report type for this data in the Reports API or in Data Kiosk. It comes from the Selling Partner API's Listings Items API (v2021-08-01) through the synchronous, paginated searchListingsItems operation. You pass the marketplace and ask for the includedData sections you want — summaries, attributes, issues, offers and fulfillmentAvailability, five of the eight the operation offers — and Amazon answers up to twenty SKUs per page. Each page returns the same item resource as the per-SKU getListingsItem, so one drain of the pages replaces thousands of single calls.

The trap is that rows are stamped with the marketplace that was requested. marketplaceIds is honoured exactly: one credential answered 723 items for the US and 60 for Canada, and every summary in both pulls carried the requested marketplace and nothing else. Amazon's own guide to searching listings covers "single or multiple Amazon stores in the same region" and points at searchListingsItems for them, with the twelve-store cap and the sellers-only restriction it states written against the per-SKU getListingsItem. The payload's own ids are still carried as reported_marketplace_id wherever Amazon writes them, so a response that spanned marketplaces would land visibly rather than mislabelled.

The second trap is in the raw JSON rather than the tables: offer prices arrive as strings ("17.0"), and the currency appears twice, under currency and currencyCode. If you parse the payload yourself, cast the price and pick one currency field; the tables here already do both.

Whether any Seller Central screen offers the same record as a download is not something this page can establish: Amazon's developer documentation for the Listings Items API names no console path, and Seller Central's own help articles sit behind a login.

Sample rows

Illustrative values, not data from a real account. Shown to give the shape of the file.

skureported_marketplace_idasinproduct_typeitem_namelast_updated_datepriceprice_currency_codefulfillment_channel_codequantity
EX-TUMBLER-BLU-20ATVPDKIKX0DERB0EXAMPLE01DRINKING_CUPExample Insulated Tumbler 20 oz Blue2026-09-10T14:02:11Z24.99USDAMAZON_NA
EX-TUMBLER-GRN-20ATVPDKIKX0DERB0EXAMPLE02DRINKING_CUPExample Insulated Tumbler 20 oz Green2026-08-29T09:15:40Z24.99USDAMAZON_NA
EX-BOTTLE-32ATVPDKIKX0DERB0EXAMPLE03WATER_BOTTLEExample Sports Water Bottle 32 oz2026-09-11T03:44:07Z17.00USDDEFAULT140
EX-LID-2PKATVPDKIKX0DERB0EXAMPLE04DRINKING_CUPExample Replacement Lids 2 Pack2026-07-02T18:30:00ZDEFAULT0

Field reference

summaries

ColumnTypeDescription
skustringThe seller SKU the listing is keyed on, and the join key every companion table carries. On this table it is one row per SKU per requested marketplace, strictly one per item on every validated pull.
reported_marketplace_idstringThe marketplace the summary is reported for, as Amazon wrote it in the summary. On every validated pull this was the marketplace that was requested.
asinstringThe ASIN the SKU is listed against in this marketplace.
product_typestringThe Amazon product type the listing is filed under. It decides which attribute names the attributes table can carry for this SKU.
condition_typestringThe condition the offer is listed in, as Amazon codes it in the summary. The reference enumerates thirteen values: new_new, new_open_box, new_oem, refurbished_refurbished, used_like_new, used_very_good, used_good, used_acceptable, collectible_like_new, collectible_very_good, collectible_good, collectible_acceptable and club_club.
statusstringThe listing status Amazon reports for the SKU in this marketplace, as it stands on the snapshot day. Upstream it is a list, not a single value, drawn from two documented statuses: BUYABLE, which shoppers can purchase and which does not apply to vendor listings, and DISCOVERABLE, visible to shoppers. A SKU can hold both, one, or neither.
fn_skustringThe FNSKU Amazon assigned to the SKU, the identifier printed on FBA unit labels.
item_namestringThe listing title as Amazon holds it. Changes in place, so a difference between two snapshots is a real title change.
created_datetimestamp_msWhen the listing was created, per the summary.
last_updated_datetimestamp_msWhen the listing was last updated, per the summary. Two snapshots with different values here mean the listing changed between pulls.
main_image_linkstringThe URL of the listing's main image as the summary carries it.
main_image_heightint64The main image's height in pixels.
main_image_widthint64The main image's width in pixels.

attributes

ColumnTypeDescription
skustringJoin key back to the summaries table. This copy sits on the attributes table, which carried one row per attribute element, so a SKU repeats here as many times as it has elements.
attribute_namestringThe attribute's key in the product-type attribute blob. This is an open vocabulary, 101 distinct names across one seller's 723 items, and which keys appear depends on the SKU's product_type.
attribute_indexint64The element's position within the attribute's value list. Every attribute value is a list of objects, so an attribute with several values produces several rows distinguished by this.
reported_marketplace_idstringThe marketplace the attribute element applies to, as Amazon wrote it on the element. Blank where the element carries none.
language_tagstringThe language tag most attribute elements carry, where the attribute is language-specific. Blank where the element has none.
valuestringThe element's scalar value, where it has one; 17,516 of 26,056 validated elements did. A convenience over value_json, which is the authoritative copy.
value_jsonstringThe whole element as canonical JSON. This is the lossless copy: anything the scalar value cannot carry, including nested objects and elements with no scalar at all, is still here.

issues

ColumnTypeDescription
skustringJoin key back to the summaries table. This copy sits on the issues table, which carried zero to three rows per validated item, so a SKU with no open issue has no row here.
issue_indexint64The issue's position in the SKU's issue list, so several issues on one SKU are distinguished by this.
codestringAmazon's issue code identifying what is wrong with the listing.
messagestringAmazon's human-readable description of the issue.
severitystringHow serious Amazon rates the issue, as it codes it in the issue. The reference enumerates ERROR (the issue prevented the submission from processing), WARNING (should be reviewed but did not block processing) and INFO (additional information to review). The API's own severity filter accepts only WARNING and ERROR, so INFO issues can be read here but not filtered for upstream.
attribute_namesstringThe listing attributes the issue is about, comma-joined into one cell. The values are identifiers that cannot carry commas, so splitting on the comma is safe.
categoriesstringThe issue categories Amazon assigns, comma-joined into one cell. Same splitting rule as attribute_names.
enforcement_actionsstringThe enforcement actions Amazon has taken or will take on the listing because of this issue, comma-joined into one cell.
exemption_statusstringWhether the listing is exempt from the enforcement action. The reference enumerates EXEMPT (permanently exempt, the action is not applied), EXEMPT_UNTIL_EXPIRY_DATE (temporarily exempt, with the deadline in exemption_expiry_date) and NOT_EXEMPT (no exemption, the action is already being enforced). Every validated exemption was NOT_EXEMPT.
exemption_expiry_datetimestamp_msWhen an exemption from the enforcement action expires, meaning the deadline before enforcement applies. Never observed populated, because every validated exemption was NOT_EXEMPT, which has no date; the column is carried from Amazon's documentation so that a deadline is not dropped if one arrives.
issue_skustringA second SKU carried on the issue itself, separately from the row's sku. Amazon's Issue schema documents no sku property at all, so what this holds relative to sku is not settled by the reference; treat the row's sku as the join key and this as unverified until a file with the two differing turns up.

offers

ColumnTypeDescription
skustringJoin key back to the summaries table. This copy sits on the offers table, which carried zero or one row per validated item.
reported_marketplace_idstringThe marketplace the offer is made in, as Amazon wrote it in the offer.
offer_typestringWhich audience the offer is for. The reference enumerates exactly two values: B2C, available to shoppers on Amazon's retail sites, and B2B, available for business purchase. Every validated offer was B2C; B2B offers, with their quantity discount plans, were not observed and are not profiled.
pricedecimalThe offer's current price. Amazon sends this as a string in the JSON ("17.0"); it is cast to a decimal here.
price_currency_codestringThe currency of price. Amazon writes it under both currency and currencyCode, identical on all 688 validated offers; only the latter is carried.
audiencestringThe buyer segment or programme the offer applies to. This one is not a closed set: the reference types it as a plain string and names only ALL (the standard audience for buyers on Amazon's retail websites) and B2B (Amazon Business buyers) as common values, so treat an unfamiliar code as real rather than as an error.
audience_display_namestringThe localized display name Amazon gives the audience code — in the getListingsItem reference's own response example, Sell on Amazon for ALL. The searchListingsItems schema types it only as a localized label, so it follows the request's locale — a label to show, not a key to join or filter on.

fulfillment_availability

ColumnTypeDescription
skustringJoin key back to the summaries table. This copy sits on the fulfillment availability table, which carried zero or one row per validated item.
fulfillment_channel_codestringThe channel the SKU is fulfilled through. DEFAULT is merchant-fulfilled; AMAZON_NA is FBA in North America.
quantityint64The quantity available on the channel. Only arrives on merchant-fulfilled channels (DEFAULT); FBA channels (AMAZON_NA) answer the channel code alone, so a blank here on an FBA SKU is expected, not missing stock.

Use cases

Finding every listing with an open issue, and what Amazon will do about it. Join the issues table to summaries on sku and sort by severity. enforcement_actions says what Amazon has done or will do to the listing, attribute_names says which fields to fix, and message says why. If you snapshot it daily, the set of code values that disappear between two pulls is your list of issues resolved.

Auditing listing content without opening every detail page. item_name and the attributes table hold what Amazon actually has for each SKU, which is not always what you last submitted. Filter attribute_name to the fields you care about, read value where it is filled and value_json where it is not, and compare across SKUs of the same product_type.

Catching price drift. price and price_currency_code are the offer as it stands today. Stacking daily snapshots by sku shows when a price moved, which is the thing to line up against a Buy Box percentage drop in the Sales and Traffic report.

Reconciling merchant-fulfilled stock. quantity on DEFAULT rows is the merchant-fulfilled quantity Amazon is selling against. It is blank on FBA rows by construction, so use it for your own-fulfilled SKUs and an FBA inventory report for the rest.

Mapping SKU to ASIN to FNSKU. The summaries table is the one place sku, asin and fn_sku sit in the same row for every listing in a marketplace, which is the join most warehouse and labelling work needs.

Spotting listings that have gone quiet. last_updated_date beside created_date tells you which listings have not been touched since they were created, and which changed yesterday when nobody meant to change them.

Limitations and gotchas

It is a snapshot, not a history. Issues appear and resolve, offers reprice, quantities move, and the record mutates in place. The rows carry no date range, only a snapshot date. If you did not keep yesterday's pull, yesterday's issue list is gone.

quantity is blank on FBA rows, and that is correct. fulfillmentAvailability.quantity only arrives on merchant-fulfilled channels (DEFAULT); FBA channels (AMAZON_NA) answer the channel code alone. A blank is not zero stock.

Attributes have no fixed schema. The keys in attribute_name are whatever the SKU's product_type defines, and every value is a list of objects. Only about two thirds of elements have a scalar value; the rest exist only in value_json. Code that reads value alone drops a third of the data.

Rows are per requested marketplace. Every summary carried the marketplace that was requested, so covering two marketplaces gives two sets of rows for the same SKU. Join the companion tables on sku within one marketplace's pull, or an attribute list will multiply.

Issue lists are comma-joined. attribute_names, categories and enforcement_actions can each hold several values in one cell. The values are identifiers that cannot carry commas, so splitting is safe, but a naive equality filter will miss rows.

exemption_expiry_date has never been seen populated. Every validated exemption was NOT_EXEMPT, which has no date. The column is carried from Amazon's documentation so a suppression deadline is not dropped if one arrives; do not read it as always empty.

B2B offers are not profiled. Every validated offer was B2C, so B2B fields (quantity discount plans) and Japan points are deliberately absent from the offers table. A seller with B2B pricing needs a validated file before those columns can be trusted.

A SKU can have no row in four of the five tables. Offers and fulfillment availability arrived zero-or-one per item and issues zero to three; a missing row is a listing with no offer, no channel entry or no issue, not a failed join.

FAQ

Is there a Reports API report type for Amazon listings items?

No. Listing data comes from the Listings Items API, whose searchListingsItems operation answers live for up to twenty SKUs per page. There is no createReport flow and no Data Kiosk dataset for it.

Why does the file have five tables and four sku columns?

Because one listings item answers five sections at once: summaries, attributes, issues, offers and fulfillment availability. Each lands as its own table, and every table carries the SKU so you can join them back together. There is no parent table beyond the SKU itself.

Why is quantity blank for my FBA SKUs?

Because Amazon only sends a quantity on merchant-fulfilled channels. FBA channels answer the channel code alone, so a blank on an AMAZON_NA row means FBA, not zero stock. Use an FBA inventory report for those.

Why does one SKU have a hundred rows in the attributes table?

The grain of that table is one row per attribute element. Attributes are an open vocabulary set by the product type, and every attribute value is a list, so a listing with many filled attributes produces many rows. Filter on attribute_name first.

Can I see when a listing issue was resolved?

Only by keeping the snapshots yourself. Each pull carries the issues open as of that day and no date range, so an issue code present yesterday and absent today was resolved in between. The file alone has no history.

Does this report include B2B prices or quantity discounts?

Not as profiled. Every offer in the validated files was B2C, so B2B fields such as quantity discount plans were not observed and are not carried. Widening to B2B needs a validated file first.

Sources

Every researched claim on this page, and the Amazon or Walmart page it came from.

  • marketplaces — developer-docs.amazon.com/listings-items-api — under `Roles for the Listings Items API v2021-08-01`, searchListingsItems carries `Regions: NA, EU, FE` (as do getListingsItem, putListingsItem, patchListingsItem and deleteListingsItem).
  • marketplaces — developer-docs.amazon.com/sp-api-endpoints — the three selling regions name every store between them: `North America (Canada, US, Mexico, and Amazon Brazil stores)`, `Europe (Ireland, Spain, UK, France, Belgium, Netherlands, Germany, Italy, Sweden, South Africa, Poland, Saudi Arabia, Egypt, Turkey, United Arab Emirates, and Amazon India stores)` and `Far East (Singapore, Australia, and Amazon Japan stores)` — the same 23 stores _taxonomy.yaml lists, which is why NA + EU + FE reads as `all`. Amazon publishes no per-store availability list for this operation, so `all` is derived from the three regions; US (723 items) and CA (60 items) were validated from one credential, which makes the rest documented rather than store-tested.
  • seller_type — developer-docs.amazon.com/listings-items-api — the version table gives `Availability: Sellers and Vendors` for v2021-08-01. The same page's roles table lists searchListingsItems for both, and the reference's includedData enum carries `procurement — Vendor procurement details for the listing item`. Only one seller credential was validated, so the vendor half of this page follows Amazon's documentation rather than an observed vendor pull. The prose is written from a seller's seat but makes no claim that is untrue for a vendor: both places the reference marks seller-only — the BUYABLE status and the multi-store `marketplaceIds` request — say so where they appear.
  • cadence — developer-docs.amazon.com/searchlistingsitems — corroboration only; `snapshot` follows the rows, which carry no requested period. searchListingsItems is `GET /listings/2021-08-01/items/{sellerId}` under a `Usage Plan: Rate (requests per second) 5, Burst 5`; there is no createReport flow, no schedule and no publication statement.
  • latency — developer-docs.amazon.com/listings-apis-faq — `There can be a delay because the Amazon backend updates every 15 minutes … In contrast, the getListingItem operation directly queries the current state, which is why the results are available faster (within 1-5 minutes).` The answer names getListingItem and not searchListingsItems, so `latency` attributes the figure to the per-SKU read and says it is carried across operations rather than published for this one.
  • latency — developer-docs.amazon.com/listings-items-api — under Considerations, `Attributes: the attributes section shows the latest data provided by the selling partner. Other sections, such as fulfillmentAvailability, represent the latest live data for the listing.`
  • how-to-get-it — developer-docs.amazon.com/searchlistingsitems — the includedData enum has eight values, `summaries`, `attributes`, `issues`, `offers`, `fulfillmentAvailability`, `procurement`, `relationships`, `productTypes`, and `Defaults to summaries`. The same parameter table gives `pageSize integer ≤ 20, Defaults to 10`, which is the twenty-per-page the page already states.
  • how-to-get-it — console path — developer-docs.amazon.com/listings-items-api — the Listings Items API page names no Seller Central or Vendor Central screen for this data, and sellercentral.amazon.com help articles serve a login shell rather than an article, so no console path could be sourced from Amazon. The body says exactly that rather than naming one, and the REVIEW comment beside it has been removed.
  • grain — developer-docs.amazon.com/searchlistingsitems — the operation answers a listings item identified by a seller SKU, with one ItemSummaryByMarketplace per Amazon store; the companion sections have their own grains (one row per attribute element, per issue, per offer, per fulfilment channel). No Amazon document settles a single term, so `listing` is kept for the headline summaries table and the other four grains are described in prose. `sku` was the other candidate.
  • fields — audience_display_name — developer-docs.amazon.com/getlistingsitem — the searchListingsItems schema gives Audience.displayName no example, but the getListingsItem reference's response example carries `audience: {value: ALL, displayName: Sell on Amazon}`, which is where the example in that column's description comes from.
  • fields — status — developer-docs.amazon.com/searchlistingsitems — ItemSummaryByMarketplace.status is an array whose enum is `BUYABLE` (`The listings item can be purchased by shoppers. This status does not apply to vendor listings.`) and `DISCOVERABLE` (`The listings item is visible to shoppers.`).
  • fields — condition_type — developer-docs.amazon.com/searchlistingsitems — ItemSummaryByMarketplace.conditionType enumerates `new_new`, `new_open_box`, `new_oem`, `refurbished_refurbished`, `used_like_new`, `used_very_good`, `used_good`, `used_acceptable`, `collectible_like_new`, `collectible_very_good`, `collectible_good`, `collectible_acceptable`, `club_club`.
  • fields — severity — developer-docs.amazon.com/searchlistingsitems — Issue.severity enumerates `ERROR`, `WARNING` and `INFO` (`Indicates additional information has been provided that should be reviewed.`). The searchListingsItems `withIssueSeverity` filter accepts only WARNING and ERROR, so INFO issues can be read but not filtered for.
  • fields — offer_type, audience, audience_display_name — developer-docs.amazon.com/searchlistingsitems — ItemOfferByMarketplace.offerType enumerates `B2C` (`available to shoppers on Amazon retail sites`) and `B2B` (`available for Business to Business purchase`). Audience.value is a plain string, `Name of the audience an offer is applicable to. Common values: 'ALL' - Standard offer audience for buyers on Amazon retail websites. 'B2B' - Offer audience for Amazon Business website buyers`, and displayName is `Localized display name for the audience` — common values, not an enum.
  • fields — exemption_status — developer-docs.amazon.com/searchlistingsitems — IssueExemption.status enumerates `EXEMPT` (permanent), `EXEMPT_UNTIL_EXPIRY_DATE` (temporary, with `expiryDate` giving when Amazon begins enforcing) and `NOT_EXEMPT` (`Amazon has already taken the specified enforcement actions`).
  • fields — main_image_* — developer-docs.amazon.com/searchlistingsitems — ItemSummaryByMarketplace carries a single `mainImage` object (`The listings item's image.`) with required `link`, `height` and `width`; the summaries section carries no other image.
  • fields — issue_sku — developer-docs.amazon.com/searchlistingsitems — the Issue schema's properties are code, message, severity, attributeNames, categories, enforcements and marketplaceIds. There is no sku property, so the reference cannot say what `issue_sku` holds. Recorded, nothing changed.
  • conflict — marketplaceIds — developer-docs.amazon.com/search-for-listings-items-by-id — `The getListingsItem operation supports multiple marketplaceIds values within the same region in a single request. Previously, you could specify only a single marketplaceIds value per request … The marketplaceIds parameter accepts a maximum of 12 Amazon stores per request. This feature is available for sellers only. This feature does not support vendor accounts because each vendor code is associated with a single Amazon store.` The searchListingsItems reference gives `marketplaceIds … A comma-delimited list of Amazon store identifiers for the request` with no max count, and the same guide says `To return details for multiple listings items across single or multiple Amazon stores in the same region, call the searchListingsItems operation`. The validated files are unchanged and still govern what the tables contain — every summary carried the requested marketplace — but the body no longer reads as though the API accepts only one store: it states what the one-marketplace pulls showed and names the multi-store request as what Amazon documents.
  • conflict — currency — developer-docs.amazon.com/searchlistingsitems — the Money schema has exactly two properties, `currencyCode` (`Three-digit currency code. In ISO 4217 format.`) and `amount`, typed as Decimal, `A decimal number with no loss of precision… Follows RFC7159 for number representation` — which corroborates the string-typed price seen in the files, but documents no `currency` field. The getListingsItem reference's response examples likewise show `price` with `currencyCode` and `amount` only. Nothing was changed: the duplicate was read off 688 real offers and that evidence governs, but the `currency` copy is undocumented, so it is not contractual and could disappear. The page carries only `currencyCode`, which is the documented one.
  • upstream.report_type — developer-docs.amazon.com/searchlistingsitems — Amazon's own name for this data is the operation, not a Reports API report type: the reference page is titled `searchListingsItems`, and its OpenAPI definition gives `"operationId": "searchListingsItems"` on `GET /listings/2021-08-01/items/{sellerId}` under `"title": "Listings Items v2021-08-01"`, which is the name the page already states throughout.