Amazon Alexa Scraper API: Structured Alexa Shopping Answers

TL;DR:

• The Amazon Alexa Scraper is a Scrapeless LLM Chat Scraper actor (scraper.alexa) that turns an Alexa shopping question into structured JSON.
• One authenticated POST to /api/v2/scraper/execute with a prompt and a country returns the answer plus the products Alexa recommends — no browser automation or app reverse-engineering.
• You get back the query, the answer in Markdown and plain text, a products array with price, rating, delivery, and ASIN, a conversation ID for follow-ups, and optional references and suggestions.
• Fields are nullable and vary by query: references, sources, and suggestions can come back empty, and prices arrive as display strings, so parse defensively.
• Start free. New Scrapeless accounts include free Scraper API credits — sign up at app.scrapeless.com.

Amazon Alexa now answers shopping questions the way a person would ask them — "best noise cancelling headphones under $300" — and replies with a written recommendation and a set of products to buy. That makes Alexa a data surface: the products it names, the prices it shows, and the order it ranks them in are all signals worth tracking. This guide shows how to capture an Alexa answer as structured data with the Scrapeless Scraping API, what the response contains, and where the fields need careful handling. Every request and field below was captured from a live run of the actor.

What You Can Do With the Amazon Alexa Scraper

The actor takes a natural-language shopping prompt and a target country and returns Alexa's answer as JSON. Practically, that lets you:

• Track product recommendations — capture which products Alexa names for a category query, with their ASIN, price, and rating, and watch how the set changes over time.
• Compare across regions — send the same prompt with a different country to see how Alexa's picks shift by market.
• Monitor AI shopping visibility — measure whether your product or a competitor's appears in Alexa's answer for the queries that matter to you.
• Feed downstream systems — pipe the structured answer into dashboards, spreadsheets, or alerts without scraping the Alexa app yourself.

Why the Scrapeless Alexa Actor

Alexa's shopping answers are generated behind an app, not served as a public web page you can request. The Scrapeless actor handles the collection and returns a clean, developer-friendly envelope, so your code sends a prompt and reads fields rather than driving an app, rotating infrastructure, or maintaining selectors. Alexa is one member of the LLM Chat Scraper family, which means the same request shape you use here also works for the other answer engines — you change the actor value and keep the rest.

Endpoint and Parameters

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

• Endpoint: POST https://api.scrapeless.com/api/v2/scraper/execute
• Actor: scraper.alexa

The response is returned synchronously in a task_result object; you do not have to poll. Get your token from the Scrapeless dashboard.

Authenticated Request

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

curl 'https://api.scrapeless.com/api/v2/scraper/execute' \
  --header 'Content-Type: application/json' \
  --header 'x-api-token: YOUR_API_TOKEN' \
  --data '{
    "actor": "scraper.alexa",
    "input": {
      "prompt": "best noise cancelling headphones under $300",
      "country": "US"
    }
  }'

Python Integration

This example reads the token from the SCRAPELESS_API_KEY environment variable, sends the request, and prints the answer and the recommended products. It uses only the Python standard library.

import json
import os
import urllib.request

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

payload = {
    "actor": "scraper.alexa",
    "input": {
        "prompt": "best noise cancelling headphones under $300",
        "country": "US",
    },
}

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("task_result", {})
print("status:", data.get("status"))
print("query:", result.get("user_text"))
print("products returned:", len(result.get("products") or []))

for product in (result.get("products") or [])[:3]:
    print("-", product.get("title"))
    print("   price:", product.get("price"), "| rating:", product.get("rating"))
    print("   asin:", product.get("product_id"))

What You Get Back

The answer arrives inside task_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.alexa run — field names are real, values trimmed.
{
  "status": "success",
  "task_id": "1ba323ef-1bee-446c-9a80-090cb9c67231",
  "task_result": {
    "user_text": "best noise cancelling headphones under $300",
    "md_text": "**Premium Noise-Cancelling Headphones** ...",
    "raw_text": "**Premium Noise-Cancelling Headphones** {cite_product_1} ...",
    "completed": true,
    "conversation": { "id": "amzn1.conversation.866ba539-..." },
    "products": [
      {
        "citation_id": "cite_product_1",
        "product_id": "B09XS7JWHH",
        "title": "Sony Premium Noise Canceling Headphones, 30-Hour Battery, Alexa Voice Control",
        "price": "~~$399.99~~ $248.00",
        "rating": "{rating 4.2} 19,796 Reviews",
        "delivery": "Delivery by July 15",
        "image_url": "<product image URL>",
        "url": "<dl.amazon.com redirect resolving to /dp/B09XS7JWHH>"
      }
    ],
    "references": [],
    "sources": [],
    "suggestions": [],
    "directives": []
  }
}

Common Data-Shape Problems

A few fields need defensive parsing:

• user_text is the query, not the answer. The answer lives in md_text (rich) and raw_text (plain). If you want the prose recommendation, read those.
• Prices are display strings, not numbers. A discounted item comes back like ~~$399.99~~ $248.00, where the struck-through value is the list price and the second is the current price. Parse the numbers out rather than casting the field directly.
• rating is a formatted string. It arrives as {rating 4.2} 19,796 Reviews, so extract the score and the review count with a small regex instead of expecting a float.
• Empty arrays are normal. references, sources, and suggestions can all be empty depending on the query, so guard for None and [] before iterating.
• Product URLs are redirects. The url is an dl.amazon.com/redirect link that resolves to the product's /dp/<ASIN> page; use product_id when you want the canonical ASIN.

Companion Actors

Because Alexa is part of the LLM Chat Scraper family, the same request pattern covers the other answer engines — swap scraper.alexa for scraper.chatgpt, scraper.gemini, scraper.perplexity, and the rest. Scrapeless also publishes an open-source Alexa scraper example repository with runnable code in five languages if you want a starting point outside Python. For another answer engine that shares the same request shape, see the ChatGPT Scraper API guide.

Conclusion

The Amazon Alexa Scraper turns a conversational shopping answer into structured JSON with one authenticated request: send a prompt and a country, read back the answer text and a products array with ASIN, price, rating, and delivery. Treat prices and ratings as strings, expect some arrays to be empty, and you have a reliable feed for tracking how Alexa recommends products across queries and regions. Amazon documents Alexa for developers, and Amazon's devices newsroom covers how the assistant is evolving.

Ready to capture Alexa answers 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 Alexa Scraper?
A: It is a Scrapeless LLM Chat Scraper actor (scraper.alexa) that sends a shopping prompt to Amazon Alexa and returns the answer as structured JSON — the query, the answer in Markdown and plain text, and a products array with ASIN, price, rating, and delivery.

Q: Which endpoint and parameters does it use?
A: POST https://api.scrapeless.com/api/v2/scraper/execute with actor set to scraper.alexa and an input object containing prompt and country. Authenticate with your token in the x-api-token header.

Q: Is the response synchronous?
A: Yes. The result comes back in the task_result object of the same response, so you do not need to poll a separate result endpoint.

Q: Do I need a browser or proxy pool?
A: No. Scrapeless runs the collection behind the API, so your application only sends the request and parses the returned JSON.

Q: Why are references, sources, or suggestions sometimes empty?
A: Those fields depend on the query. A simple category prompt may return products with no separate citations or follow-up suggestions, so treat the arrays as optional and guard before iterating.

Q: How do I read the price and rating?
A: Both are display strings. Price arrives like ~~$399.99~~ $248.00 (list price struck through, current price after), and rating like {rating 4.2} 19,796 Reviews. Extract the numbers with a small parser rather than casting the field directly.

Q: Can I use the same code for other AI assistants?
A: Yes. Alexa shares the LLM Chat Scraper request shape with the other engines, so swapping scraper.alexa for scraper.chatgpt, scraper.gemini, or scraper.perplexity reuses the same integration.