Amazon Search Scraper API: Organic & Sponsored Results as JSON

TL;DR:

• The Amazon Search Scraper is the scraper.amazon actor with type: "keywords" — it turns a search term into Amazon's ranked results as JSON.
• One authenticated POST to /api/v1/scraper/request returns organic and sponsored listings, each with position, ASIN, title, price, rating, and review count.
• Organic and paid results are separated, so you can track where a product ranks and which competitors are buying the sponsored slots above it.
• Prices and ratings arrive as display strings ("$24.98", "4.9 out of 5 stars"), so parse them rather than casting directly.
• Start free. New Scrapeless accounts include free Scraper API credits — sign up at app.scrapeless.com.

Amazon search is where product discovery happens, and the order of the results page decides which products get seen — which is why Amazon sellers track their keyword rank closely. The Scrapeless Scraping API captures a keyword's results page as structured data: the organic ranking, the sponsored placements, and the ASIN, price, and rating of every listing. This guide shows the request, the response shape, and the fields that need care. Every request and field below was captured from a live run of the actor.

What You Can Do With the Amazon Search Scraper

The actor takes a keyword and returns Amazon's ranked results as JSON. Practically, that lets you:

• Track keyword rank — capture your product's organic position for a search term and watch it move over time.
• Monitor the sponsored layer — see which ASINs are buying the paid slots above the organic results for your keywords.
• Map a category's competition — pull the full first page of ASINs, prices, and ratings for a search and compare the field.
• Feed pricing and assortment models — pipe the structured results into dashboards or alerts without parsing HTML.

Why the Scrapeless Amazon Actor

Amazon's search results page is heavily rendered and anti-bot protected, and its HTML shifts constantly. The Scrapeless actor runs the search and returns a clean, developer-friendly envelope, so your code reads fields instead of maintaining selectors, rotating infrastructure, or handling blocks. The same scraper.amazon actor also covers product detail and the Rufus assistant by changing the type.

Endpoint and Parameters

The actor runs on the synchronous Scraping API endpoint. Authenticate with your token in the x-api-token header.

• Endpoint: POST https://api.scrapeless.com/api/v1/scraper/request
• Actor: scraper.amazon

The result is returned synchronously in a result object; you do not have to poll.

Authenticated Request

A minimal request looks like this (illustrative — replace the token):

curl 'https://api.scrapeless.com/api/v1/scraper/request' \
  --header 'Content-Type: application/json' \
  --header 'x-api-token: YOUR_API_TOKEN' \
  --data '{
    "actor": "scraper.amazon",
    "input": {
      "type": "keywords",
      "keywords": "wireless headphones",
      "domain": "www.amazon.com"
    }
  }'

Python Integration

This example reads the token from the SCRAPELESS_API_KEY environment variable, runs the search, and prints the organic and sponsored results. It uses only the Python standard library.

import json
import os
import urllib.request

API_URL = "https://api.scrapeless.com/api/v1/scraper/request"
API_TOKEN = os.environ["SCRAPELESS_API_KEY"]

payload = {
    "actor": "scraper.amazon",
    "input": {
        "type": "keywords",
        "keywords": "wireless headphones",
        "domain": "www.amazon.com",
    },
}

request = urllib.request.Request(
    API_URL,
    data=json.dumps(payload).encode("utf-8"),
    headers={"Content-Type": "application/json", "x-api-token": API_TOKEN},
    method="POST",
)

with urllib.request.urlopen(request, timeout=180) as response:
    data = json.loads(response.read().decode("utf-8"))

result = data.get("result", {})
listings = result.get("result", {})
organic = listings.get("organic") or []
paid = listings.get("paid") or []

print("keyword:", result.get("keyword"))
print("organic results:", len(organic))
print("paid results:", len(paid))

for item in organic[:5]:
    print(f"  #{item.get('pos')} {item.get('asin')} {item.get('price')} {item.get('rating')}")
    print("    ", (item.get("title") or "")[:70])

What You Get Back

The results arrive inside result. The fields below are the ones you will use most; values are an illustrative sample from a live run, trimmed for length.

// Illustrative sample from a live scraper.amazon (type keywords) run — field names are real, values trimmed.
{
  "result": {
    "keyword": "wireless headphones",
    "current_page": 1,
    "total_results_count": 16,
    "result": {
      "organic": [
        {
          "pos": 3,
          "asin": "B0H3PSK8LR",
          "title": "HAOYUYAN Wireless Earbuds, Sports Bluetooth Headphones ...",
          "price": "$24.98",
          "rating": "4.9 out of 5 stars",
          "reviews_count": "1,204",
          "is_prime": true,
          "best_seller": false,
          "is_sponsored": false,
          "url_image": "<product image URL>"
        }
      ],
      "paid": [
        {
          "pos": 1,
          "asin": "B0DGMHKDWQ",
          "title": "Gabba Goods Wireless Over Ear Bluetooth Headphones ...",
          "price": "$19.99",
          "rating": "4.2 out of 5 stars",
          "is_sponsored": true
        }
      ]
    }
  }
}

Organic vs Sponsored

The response separates organic from paid, and that split is the point. Organic positions show where a product ranks on merit; the paid array shows which ASINs are buying visibility above it. Tracking both for your keywords tells you two different things — how your listing is ranking, and how much sponsored pressure sits on top of it. Each item also carries an is_sponsored flag, so you can reconcile the two views.

Common Data-Shape Problems

• Prices and ratings are display strings. price is "$24.98" and rating is "4.9 out of 5 stars", so extract the numbers with a small parser rather than casting the field. reviews_count ("1,204") is a string too.
• Read from result.result. The listings sit one level in: the top-level result holds the query metadata, and result.result.organic / result.result.paid hold the listings.
• paid can be empty. Some keywords have no sponsored layer; guard for an empty array before iterating.
• Positions are per-page. pos is the rank within the returned page, so pin current_page when you compare runs over time.

Companion Actors

The keywords type is one mode of the Amazon actor. Switch type to product to turn an ASIN into a full product record, or to rufus to capture Amazon's shopping assistant — the endpoint and authentication stay the same, only the type and its inputs change. For another actor in the same Scraper API family, see the ChatGPT Scraper API guide. Amazon documents its own Sponsored Products program, and covers the retail side in its retail newsroom.

Conclusion

The Amazon Search Scraper turns a keyword into structured, ranked results with one authenticated request: send a term and a storefront, read back the organic and sponsored listings with ASIN, price, rating, and review count. Parse the display-string prices and ratings, read the listings from result.result, and you have a reliable feed for rank tracking, sponsored monitoring, and competitive analysis.

Ready to capture Amazon search as data? Start free from the Scrapeless dashboard, see where the actor fits on the Scraping API product page, or compare plans on Scrapeless pricing.

FAQ

Q: What is the Amazon Search Scraper?
A: It is the Scrapeless Scraping API actor scraper.amazon with type: "keywords", which sends a search term to Amazon and returns the ranked results as JSON — organic and sponsored listings with position, ASIN, title, price, rating, and review count.

Q: Which endpoint and parameters does it use?
A: POST https://api.scrapeless.com/api/v1/scraper/request with actor set to scraper.amazon and an input object containing type: "keywords", keywords, and domain. Authenticate with your token in x-api-token.

Q: How do I tell organic from sponsored results?
A: The response returns two arrays, result.organic and result.paid, and each listing also carries an is_sponsored flag, so you can separate merit ranking from paid placement.

Q: Are the price and rating numbers?
A: No, they are display strings — price like "$24.98" and rating like "4.9 out of 5 stars". Extract the numbers with a small parser rather than casting the field.

Q: Is the response synchronous?
A: Yes. The result object is returned in the same response; you do not poll a separate endpoint.

Q: Can the same actor scrape a product or the Rufus assistant?
A: Yes. Change type to product for a full ASIN record, or to rufus for Amazon's shopping assistant — the endpoint and authentication stay the same.