Alexa Scraper API Guide: Extract Answers, Citations, and Products

TL;DR:

• Alexa Scraper turns a prompt into structured answer data. The scraper.alexa actor returns Markdown and plain-text answers together with references, sources, suggestions, and conditional product records.
• The request has two required actor inputs. Send a natural-language prompt and a country code to the Alexa actor.
• The current documented endpoint is /api/v2/scraper/request. Authenticate with the x-api-token header and send JSON over HTTP POST.
• Product fields are nullable by design. The products array can be empty when an Alexa answer has no product context.
• References and sources should stay attached to the answer. Keeping these child records with the capture preserves the evidence behind downstream brand, GEO, and product analysis.
• Free to start. New Scrapeless accounts include access to a free plan at app.scrapeless.com.

Introduction: Alexa Answers Need a Stable Data Interface

An Alexa answer contains more than a sentence. It can carry Markdown, plain text, references, source links, suggested follow-up questions, conversation identifiers, processing directives, and product records. Copying the visible answer loses much of that structure.

Scrapeless Alexa Scraper exposes the response through the scraper.alexa actor. A client sends a prompt and country, and the actor returns fields that can be stored without parsing a voice-assistant interface. That makes the same request shape useful for GEO monitoring, answer-quality review, source analysis, and product visibility work.

This guide uses the current Alexa Scraper documentation. It covers the endpoint, authentication, request parameters, response fields, a cURL request, a Python client, and a storage pattern for structured output.

What You Can Do With Alexa Scraper

Alexa Scraper supports workflows that need the answer and its surrounding evidence in one record.

• Capture answer text. Store md_text for rendered content and raw_text for plain-text processing.
• Inspect citations. Read reference IDs, titles, and URLs from references.
• Map source links. Store source display text, URL, type, and fragment URI from sources.
• Discover follow-up prompts. Collect the text and message values Alexa presents in suggestions.
• Track response context. Preserve completion state, answer revision, dialog request ID, endpoint ID, fragment count, and conversation ID.
• Analyze product surfacing. Read product identifiers, citation links, titles, images, URLs, prices, delivery text, details, and purpose when product data applies.

The actor returns capture data. Metrics such as mention rate, source concentration, answer consistency, and product appearance rate are downstream calculations defined by the team using the data.

Why the Scrapeless Alexa Scraper

Scrapeless Alexa Scraper provides a documented actor interface for capturing Alexa responses across markets.

The implementation value comes from the response shape:

• Answer text arrives in Markdown and plain-text formats.
• Citations and source links are separate arrays rather than links embedded only in prose.
• Suggested prompts are returned as structured records.
• Product information is available as a conditional array.
• Country is an explicit request input for market-specific capture.
• Conversation and answer identifiers can be retained for traceability.

Scrapeless LLM Chat Scraper is part of the Universal Scraping API line. The Universal Scraping API product page is the product home, and current plan details are listed on the Scrapeless pricing page.

Prerequisites

You need:

• A Scrapeless account and API key from app.scrapeless.com
• cURL for the shell example
• Python and the requests package for the Python example
• A supported country code for the market you want to capture

The country input uses a short country code. The ISO 3166 country-code standard explains the common alpha-2 format; use the Scrapeless supported-country list to confirm product availability for a specific code.

Note: The authenticated requests below require a real Scrapeless API key and reachable webhook. Without those credentials, the blocks can be syntax-checked but cannot produce a live Alexa result.

How the Alexa Scraper API Works

The Alexa Scraper request is an HTTP POST that names the actor, supplies the prompt and country, and provides a webhook destination.

The current documented endpoint is:

https://api.scrapeless.com/api/v2/scraper/request

HTTP defines request methods and header fields through the HTTP semantics standard. In this request, Content-Type: application/json describes the body format and x-api-token carries the Scrapeless API key.

Keep that API key in a secrets store or protected environment variable rather than source code. The OWASP secrets-management guidance outlines practical controls for storage, rotation, and access.

Request Parameters

Keep the prompt and country in the same database record as the returned answer. Those two inputs define the observation and make later comparisons reproducible.

Quick Capture With cURL

Set SCRAPELESS_API_KEY and SCRAPELESS_WEBHOOK_URL in the shell before running the request.

Note: This block is a credential-gated request. It needs a real Scrapeless API key and a public webhook URL.

curl 'https://api.scrapeless.com/api/v2/scraper/request' \
  --header 'Content-Type: application/json' \
  --header "x-api-token: ${SCRAPELESS_API_KEY}" \
  --data-binary @- <<JSON
{
  "actor": "scraper.alexa",
  "input": {
    "prompt": "Recommended attractions in New York",
    "country": "US"
  },
  "webhook": {
    "url": "${SCRAPELESS_WEBHOOK_URL}"
  }
}
JSON

The payload is JSON, whose interoperable grammar is defined by RFC 8259. Keep string values quoted and avoid comments inside the submitted body.

Response Fields

The actor result groups fields into answer content, identifiers, directives, references, sources, suggestions, and products.

The following JSON is an illustrative shape built from the documented field list. Values are examples, not a captured actor run.

{
  "user_text": "Which coffee maker fits a small kitchen?",
  "md_text": "A compact coffee maker should balance footprint and capacity.",
  "raw_text": "A compact coffee maker should balance footprint and capacity.",
  "completed": true,
  "answer_revision": 1,
  "conversation": {
    "id": "illustrative-conversation-id"
  },
  "references": [
    {
      "id": "cite_example",
      "title": "Illustrative buying guide",
      "url": "https://example.com/illustrative-buying-guide"
    }
  ],
  "sources": [
    {
      "text": "Illustrative source",
      "url": "https://example.com/illustrative-buying-guide",
      "type": "OpenURL",
      "fragment_uri": "illustrative-source-fragment"
    }
  ],
  "suggestions": [
    {
      "text": "Compare compact models",
      "message": "Compare compact coffee makers",
      "type": "TextMessage",
      "fragment_uri": "illustrative-suggestion-fragment"
    }
  ],
  "products": []
}

The empty product array is intentional. Product information is conditional, so parsers must accept an empty list.

Get your API key on the free plan: app.scrapeless.com

Integrating the Alexa Scraper in Python

A Python client can submit the documented request and print the request-workflow response. The final Alexa actor result is delivered through the configured workflow and should be passed to the normalization function shown after the request.

Install the only third-party dependency. This setup step requires access to a Python package index.

python -m pip install requests

Note: The request block below is a credential-gated example. It requires SCRAPELESS_API_KEY and SCRAPELESS_WEBHOOK_URL environment variables.

import os
import requests

API_URL = "https://api.scrapeless.com/api/v2/scraper/request"

api_key = os.environ["SCRAPELESS_API_KEY"]
webhook_url = os.environ["SCRAPELESS_WEBHOOK_URL"]

payload = {
    "actor": "scraper.alexa",
    "input": {
        "prompt": "Recommended attractions in New York",
        "country": "US",
    },
    "webhook": {
        "url": webhook_url,
    },
}

response = requests.post(
    API_URL,
    headers={
        "Content-Type": "application/json",
        "x-api-token": api_key,
    },
    json=payload,
    timeout=60,
)
response.raise_for_status()
print(response.json())

Keep the API key in an environment variable. Do not place it in source control, notebooks, screenshots, or captured webhook payloads.

Normalizing Alexa Output for Storage

A normalized Alexa record keeps the answer at the parent level and stores repeating arrays as child records.

Use a parent captures table with:

• Internal capture ID
• Submitted prompt
• Submitted country
• user_text, md_text, and raw_text
• completed and answer_revision
• Conversation and dialog identifiers
• Capture timestamp generated by your system

Store references, sources, suggestions, directives, and products in separate tables keyed to the capture ID. This avoids duplicating the full answer for every source or product.

Source relationships should remain explicit and queryable. The actor already exposes those relationships through citation IDs, source URLs, and fragment URIs. Preserve them instead of flattening them into an unstructured text field.

For product rows, keep citation_id even when it is null. When present, it can associate the product with a documented reference. When absent, the null value accurately records that no direct citation link was returned in that field.

How to Avoid Common Integration Problems

Alexa Scraper integrations stay predictable when nullable fields, country scope, and response evidence are handled explicitly.

Treat Conditional Arrays as Empty Collections

The products array can be empty when product information does not apply. The same defensive pattern is useful for references, sources, suggestions, and directives: read a missing or null array as an empty collection in the transformation layer, while retaining the original payload for audit.

Keep Markdown and Plain Text

md_text and raw_text support different jobs. Markdown is useful for rendering and preserving visible structure. Plain text is easier to tokenize, compare, and search. Storing both prevents a later pipeline from reconstructing one format from the other.

Pin the Country in Every Record

Do not rely on a default market in downstream storage. Save the exact submitted country beside the prompt and result. Market comparisons fail when captures cannot be tied back to the request context.

Preserve Citation IDs Before Grouping by Domain

Domain-level reporting is useful, but it should be derived from the original reference and source records. Keep the citation ID, title, full URL, source type, and fragment URI before adding normalized domain fields.

Separate Actor Output From Derived Scores

The actor returns answer and context fields. Mention rate, citation rate, source diversity, claim accuracy, and product appearance are analytics created after capture. Store derived scores in a separate table or namespace so a reviewer can distinguish API output from the team's interpretation.

Companion Reading for Answer-Engine Data

Alexa Scraper covers one LLM answer surface. The Google AI Overview Scraper API guide shows a related actor pattern for a search-led answer experience with its own field model.

Use a shared storage contract across actors only for fields that truly align: submitted prompt, country, answer text, source URL, capture ID, and capture time. Keep actor-specific fields in their own tables so product fragments, suggestion messages, and platform identifiers do not disappear into a lowest-common-denominator schema.

Conclusion: Preserve the Answer and Its Evidence

The Alexa Scraper integration has a small request surface: actor, prompt, country, authentication header, and webhook workflow. The response model is broader because it preserves the answer, references, sources, suggestions, directives, conversation context, and conditional products.

Start by storing the raw payload and a normalized parent capture. Add child tables for repeating records, retain nullable product fields, and keep derived analytics separate from actor output. That structure supports future brand, GEO, product, and market use cases without rewriting the collection layer.

Ready to Build With Alexa Scraper?

Join our community to claim a free plan and connect with developers building LLM-answer data pipelines: Discord · Telegram.

Sign up at app.scrapeless.com and test the actor with one prompt, one supported country, and a webhook endpoint you control.

FAQ

Q: Which endpoint does Alexa Scraper use?

Alexa Scraper uses POST https://api.scrapeless.com/api/v2/scraper/request in the current actor documentation. The request uses scraper.alexa as the actor value.

Q: Which Alexa Scraper inputs are required?

The actor requires a prompt and country code inside the input object. The documented request example also includes a webhook URL for the request workflow.

Q: What is the difference between md_text and raw_text?

md_text is the Markdown-formatted Alexa answer, while raw_text is the plain-text answer. Store both when the pipeline needs faithful rendering and text analysis.

Q: Does Alexa Scraper always return citations?

Alexa Scraper exposes references and sources arrays, but downstream code should allow those arrays to be empty. The presence of citations depends on the returned answer.

Q: Does Alexa Scraper always return products?

No. Product information is conditional, and the products array can be empty when it does not apply.

Q: Can Alexa Scraper be used without Python?

Yes. Any client that can send an authenticated JSON POST and receive the request workflow's response can use the actor. The cURL example is sufficient for a direct integration test.

Q: How should API keys be stored?

Store the Scrapeless API key in an environment variable or a managed secret store. Do not commit the key to source control or include it in webhook logs.