Walmart Product Data for AI Agents: From Item ID to Seller Profile

Walmart product data for AI agents comes down to two lookups that depend on each other: the product source tells an agent what a listing is right now, and the seller source tells it who is selling it. This guide follows one real item from item ID to seller profile and storefront, explains the seller ID mistake that stops most lookups, and prices each call in points. For exact fields, request shape and prices, the Walmart product source page is the reference.

The short version

• —The answer: send the product source an item ID or product URL, read the seller block, and pass seller.storefront_url to the seller sources. The 32-character seller ID on the product page will not work.
• —What you get back: named fields instead of a page: price as a number with a currency, rating, review count, stock flag, and the seller behind the listing.
• —Who it is for: agents and teams that need to answer "what is this listing, who sells it, and can I trust them?" without a browser or a scraper to maintain.
• —What it costs: 5 points for a product lookup and 5 for a seller lookup. Search, storefront listings and reviews cost 1 point per returned record. A lookup that does not resolve is not billed.
• —How to reach it: the same sources run over REST and as tools on the hosted MCP server, with matching arguments.

Walmart product data for AI agents, step by step

Plenty of what sells on Walmart.com comes from third-party sellers, not Walmart. A useful agent therefore needs a chain: item first, seller second, storefront third. Each step is one request with one identifier, and each response is a single JSON object with a session_id you can trace, a kind naming the source, the identifier you sent, a short human summary, a machine object with the structured record, and total_points at the bottom. Every read happens at request time, so price and stock match the listing at that moment and can change right after.

The walkthrough follows one real chain, for a vinyl record player sold by a third-party seller. Replace YOUR_API_KEY with your key. Endpoint and parameter details live at docs.neuralverge.ai.

1. Look up the item

The product request takes a Walmart item ID such as 15290971475 or a full product URL:

curl -X POST https://api.neuralverge.ai/functions/v1/run-walmart-product \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "item": "15290971475" }'

The full response is long (image lists, a detailed return policy), so this is a shortened excerpt of the real response. The ... marks fields left out of this post:

{
  "session_id": "11111111-1111-1111-1111-111111111111",
  "kind": "walmart_product",
  "item": "15290971475",
  "machine": {
    "product": {
      "id": "15290971475",
      "us_item_id": "15290971475",
      "walmart_internal_id": "0W0FAWCUKZIK",
      "name": "LoopTone Vinyl Record Player Turntable with Bluetooth, CD, Tape, Radio, USB Recorder, Stereo Home System",
      "brand": "LoopTone",
      "model": "18CDBB-B",
      "upc": "797457436581",
      "price": 129.99,
      "price_string": "$129.99",
      "currency": "USD",
      "list_price": 199.99,
      "rating": 4.3,
      "review_count": 644,
      "availability_status": "IN_STOCK",
      "is_in_stock": true,
      "seller": {
        "id": "47D6101AABDC40719510F4D0079EEF41",
        "name": "huizhoushideshengyuandianziyouxiangongsi",
        "display_name": "LoopTone",
        "storefront_url": "https://www.walmart.com/global/seller/102730552",
        "type": "EXTERNAL"
      },
      "category": "Turntables and Record Players",
      "condition": "New",
      "is_preowned": false,
      ...
    }
  },
  "total_points": 5
}

The lookup cost 5 points. Compared with reading the page by hand, every value is typed: the price is a number, the rating is a number and the stock flag is a boolean. Compared with a scraper you maintain, the repair work after each layout change is not yours, though you get the fields the source returns and not whatever the page happens to show.

2. Read the seller block, and avoid the ID trap

In the seller block, the id is the 32-character hash shown on the product page. It looks like an ID, but the seller sources do not accept it. They need either the numeric catalogSellerId (for example 102730552) or a full storefront URL. The storefront_url here ends in 102730552, and that works. The source page is blunt about it: that field is the only reliable place to get the ID the seller endpoint needs. Also note that name is a registered company name while display_name is the storefront brand.

Your agent should branch on seller.type:

• —EXTERNAL: a third-party seller. storefront_url holds a real link to chain into the seller sources.
• —INTERNAL: Walmart sells the item itself. storefront_url is null and there is nothing to look up.

3. Look up the seller

Take that storefront URL, or just its numeric ID, to the Walmart seller source:

curl -X POST https://api.neuralverge.ai/functions/v1/run-walmart-seller \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "seller": "102730552" }'

This is the complete response, captured from a real request and copied from the source page with nothing shortened:

{
  "session_id": "11111111-1111-1111-1111-111111111111",
  "kind": "walmart_seller",
  "seller": "https://www.walmart.com/global/seller/102730552",
  "human": "# Walmart seller\n\n- **Seller:** https://www.walmart.com/global/seller/102730552\n- **Response size:** 482.5 KB\n- **Name:** LoopTone\n- **Rating:** 4.424050632911392 (163 reviews)\n- **Location:** Huizhou, GD, CN\n- **Status:** ACTIVE",
  "machine": {
    "seller": {
      "id": "102730552",
      "url": "https://www.walmart.com/seller/102730552",
      "name": "LoopTone",
      "legal_name": "huizhoushideshengyuandianziyouxiangongsi",
      "type": "EXTERNAL",
      "is_pro_seller": false,
      "rating": 4.424050632911392,
      "review_count": 163,
      "text_review_count": 26,
      "image": "https://i5.walmartimages.com/asr/46c8ddb7-a33e-4cc2-a9fd-4a81df9a5f3f.8742a7a126069628a7a767ec11ea6cc3.jpeg",
      "banner": null,
      "location": "Huizhou, GD, CN",
      "address": "No.10 Qingtang North Road Xiaojinkou",
      "city": "Huizhou",
      "state": "GD",
      "country": "CN",
      "postal_code": "516023",
      "email": "[redacted]",
      "phone": "[redacted]",
      "status": "ACTIVE",
      "is_active": true,
      "is_alcohol_seller": false,
      "is_qsr_seller": false
    },
    "response_bytes": 494109
  },
  "total_points": 5
}

The call cost 5 points, shown as total_points. The Walmart seller source page lists it as $5 per 1,000 lookups. How to read the fields:

• —type is EXTERNAL for a marketplace seller and INTERNAL for Walmart.com itself.
• —legal_name is the registered business name, the field you want for due diligence. It matches the name inside the product response.
• —rating, review_count and text_review_count are Walmart's own aggregation, not an independent audit. The rating is a long decimal, so round it for display.
• —location, address, city, state, country and postal_code are what the seller publishes. Here the seller is based in China, which a buyer wants to know before sourcing.
• —email and phone appear only if the seller publishes them. We redacted both in the sample above. Treat contact data with care.
• —status and is_active tell you whether the account is live. Unset fields such as banner come back as null.

4. List the seller's storefront

Once you know who the seller is, the next question is usually what else they sell. The Walmart seller products source takes the same seller identifier:

curl -X POST https://api.neuralverge.ai/functions/v1/run-walmart-seller-products \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "seller": "102730552", "max_items": 10 }'

It returns one record per product: id, name, url, price, currency, list_price, image, rating, review_count and availability. The response also carries total_available, the number of products in the storefront beyond the batch you asked for. In the captured sample, max_items was 2, two records came back, and total_available was 10. The first record was item 15290971475 at 129.99 USD with a list price of 199.99, the same item the chain started with, which is a quick sanity check that you reached the right storefront. The second was an AM/FM radio, item 16463519139, at 39.89 USD. Two records cost 2 points: 1 point per returned product. You can page further with start_page, up to 250 products per request.

The storefront listing uses availability as a text string ("In stock"), while the product source uses availability_status and a boolean is_in_stock. If you merge records from both, normalize the stock fields first.

Finding items to look up

You do not always start from an item ID. Walmart product search takes a keyword and returns listings with item ID, price, rating, category and a seller block. It supports sort options (best_match, price_low, price_high, best_seller, new and rating_high) and min_price and max_price bounds, at 1 point per returned result, up to 250 per request. Results can include sponsored items, marked is_sponsored. Walmart product reviews returns customer reviews for an item, one record per review at 1 point each, which suits sentiment work. A common pattern is to search first, run the product source on the item IDs you keep, and chain into the seller sources only for third-party listings.

A worked example with Acme Oy

Suppose Acme Oy, a fictional Finnish audio company, wants to know who it competes with on Walmart.com for record players. Its analyst searches the category, runs the product source on the top item IDs, and saves storefront_url for every listing marked EXTERNAL. Listings marked INTERNAL are recorded as sold by Walmart. She then runs the seller source on each saved storefront and keeps legal_name, rating, country and status, and finally lists the storefronts of the sellers who appear most often. Every step is a call with a stated cost, and the sellers in her sheet are whatever the lookups return that day.

REST and MCP

Every Walmart source is reachable over REST and as a tool on the hosted MCP server, so an agent can make the same call without a hand-written REST client. The seller call from step 3 looks like this over MCP:

{ "tool": "run_walmart_seller", "arguments": { "seller": "102730552" } }

The tool names are run_walmart_product, run_walmart_seller, run_walmart_seller_products, plus search and reviews equivalents. Tool names use underscores, REST paths use hyphens, and the arguments match the REST body, so the chain above works the same way in both. For connecting the server to Claude and other clients, see MCP server for Claude.

For an agent, the practical gain is that each step returns structured fields it can reason over. Asked "who sells this and are they reliable?", it runs the product lookup, reads the seller block, branches on seller.type and calls the seller source only when the type is EXTERNAL.

What it costs

All figures below come from the source pages, at the time of writing.

The chain in the walkthrough, one product lookup, one seller lookup and a storefront listing capped at 10 products, costs at most 5 + 5 + 10 = 20 points. That is simple arithmetic on the listed rates, and it assumes everything resolves and the storefront has at least 10 products. In the captured sample it had exactly 10.

Two billing details matter for planning. Lookups that do not resolve are not billed, so a bad item ID costs nothing. List sources are billed per record actually returned and capped by max_items, so set that cap on purpose rather than leaving it at the default. The pricing page explains how points are bought and spent across all sources.

Limits to plan around

• —Snapshots, not streams. Price and stock are read when you ask. Schedule the lookup and store each reading with your own timestamp.
• —The seller ID rule is strict. An ID from anywhere other than a product response's storefront_url may not resolve.
• —Contact data is partial, and third-party listings vary in how much seller detail they include.
• —Public listings only. Coverage is Walmart.com listings and sellers with a public page.

Common mistakes

• —Passing the page hash. The 32-character seller ID from the product page is not accepted by the seller sources. Use storefront_url or the numeric ID.
• —Assuming every listing has a seller to look up. INTERNAL listings have no storefront, and storefront_url is null.
• —Leaving list requests uncapped. You pay per returned record, so set max_items.
• —Merging stock fields without normalizing. Product uses availability_status and is_in_stock; storefront listings use availability.
• —Keeping readings without a timestamp. The source does not tell you how the price will look in an hour.

How to decide

1. —Which job is it? Price tracking on a watch list, supplier vetting, competitor mapping, assortment gap analysis or an agent tool each map to a different part of the chain. Price tracking needs only the product source, and seller.type tells you whether a move came from Walmart or a third party. Vetting and mapping need the seller sources too.
2. —Do you have the right identifier? Item ID or product URL for the product source; numeric catalogSellerId or storefront URL for seller sources.
3. —Is the seller on the listing third-party? If your code branches on seller.type, only EXTERNAL listings cost a second call.
4. —Is a snapshot enough? If you need freshness, plan a schedule and your own timestamps.
5. —What will you do with contact data? Email and phone are published by the seller, but you still need a reason and a lawful basis for using them.
6. —Is Walmart the only marketplace you track? If not, the same pattern applies to the other marketplace sources in the data catalog.

Frequently asked questions

Why does my Walmart seller lookup fail with the ID from the product page?

The seller ID on a Walmart product page is a 32-character hash, and the seller sources do not accept it. They need the numeric catalogSellerId or a full storefront URL. Run the Walmart product source on the same item and take the value from seller.storefront_url in the response.

What does a Walmart lookup cost?

The Walmart product source and the Walmart seller source each cost 5 points per successful lookup, which the source pages list as $5 per 1,000. Keyword search, seller products and reviews cost 1 point per returned record, listed as $1 per 1,000. A lookup that does not resolve is not billed.

Can I look up a Walmart item by URL instead of item ID?

Yes. The item field on the Walmart product source accepts either a Walmart item ID or a full product URL. The seller field on the seller sources accepts either the numeric catalogSellerId or a storefront URL.

What happens for items that Walmart sells itself?

The seller block on those items has the type INTERNAL and storefront_url is null, because there is no marketplace storefront to look up. The seller lookup only applies to third-party sellers, which are marked EXTERNAL.

Can an AI agent call the Walmart sources through MCP?

Yes. The Walmart sources are available over REST and as MCP tools on the hosted MCP server: run_walmart_product, run_walmart_seller and run_walmart_seller_products. The arguments match the REST body.

How current is the price and stock in the response?

Each lookup is read at request time, so the price and stock match the listing at that moment. They can change immediately afterwards, so store each reading with your own timestamp and re-run the lookup when freshness matters.