# Amazon Rufus AI Answers Scraper (`cyprusapi/amazon-rufus`) Actor

Answers from Rufus, Amazon's AI shopping assistant, per ASIN — your own questions or Amazon's suggestion chips, verbatim answer text plus suggested questions. Beta: logged-in sessions operated by the publisher, amazon.de only. Pay-per-answer; unanswered ASINs are never charged.

- **URL**: https://apify.com/cyprusapi/amazon-rufus.md
- **Developed by:** [Torchtechnology LTD](https://apify.com/cyprusapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 answers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Amazon Rufus AI Answers Scraper do?

**The only Actor that returns what Rufus — Amazon's AI shopping assistant — actually tells shoppers.** For each ASIN you get the **verbatim Rufus answers** to your own free-text questions or to Amazon's own suggestion chips, plus the full list of suggested questions. **$1 per 1,000 answers ($0.001 per answer delivered)** — you only pay for answers actually returned; ASINs where Rufus has nothing to say are never charged.

Built for **AI-visibility monitoring**: track what Amazon's AI tells shoppers about your products — or your competitors'.

Runs on the Apify platform: API access, scheduling, integrations, and monitoring included.

### Why use Amazon Rufus Scraper?

- **AI-visibility monitoring** — Rufus increasingly answers shopper questions instead of your listing. Know what it says about your ASINs: which claims it repeats, which concerns it raises, which competitors it mentions.
- **Suggestion intelligence** — the questions Amazon suggests per product reveal what shoppers (and Amazon's ranking) consider undecided about the product.
- **Competitor research** — run the same question set across competitor ASINs and compare what Rufus recommends.
- **Listing optimization** — if Rufus answers a key buying question wrongly or vaguely, that's a concrete gap to fix in your bullets, A+ content, or images.
- **Honest billing** — you only pay per **answer actually delivered**. ASINs without a Rufus widget, failed questions, or backend errors produce free transparency items that say exactly why.

### How to use Amazon Rufus Scraper

1. Open the Actor and go to the **Input** tab.
2. Add one or more **ASINs** (or paste product URLs).
3. Optionally add your own **questions** — or leave the field empty to use Amazon's suggestion chips.
4. During the publisher-run beta, the **session backend** fields are preconfigured for invited users.
5. Click **Start** and wait a few minutes per ASIN. Download the dataset as JSON, CSV, or Excel, or consume it via the Apify API.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `asins` | array | — | ASINs to ask Rufus about (10 characters each) |
| `productUrls` | array | — | Amazon product URLs; ASINs are extracted automatically |
| `marketplace` | string | `de` | `de`, `es`, `it`, `fr` or `com` — all five verified live on the logged-in backend (2026-08-19). Rollout quota and throttling limits per marketplace are still unknown, so the conservative caps below apply everywhere |
| `questions` | array | *(empty)* | Your own questions, asked verbatim per ASIN (max 5). Empty = Amazon's suggestion chips are clicked instead |
| `maxQuestionsPerAsin` | integer | `3` | Upper bound of questions per ASIN (hard cap 5 — conservative on purpose, see limitations) |
| `sessionBackendUrl` | string | — | Publisher-operated session backend (preconfigured for beta users) |
| `sessionBackendToken` | string | — | Backend API token (secret) |
| `sessionBackendBasicAuth` | string | — | Optional `user:password` for an extra auth layer in front of the backend (secret) |

### Output

One dataset item **per answered question** (charged), one uncharged metadata item per ASIN, and uncharged transparency items when an ASIN delivers nothing.

```json
{
  "type": "answer",
  "asin": "B00008XF6W",
  "marketplace": "de",
  "productUrl": "https://www.amazon.de/dp/B00008XF6W",
  "question": "Für wen ist dieses Produkt besonders gut geeignet?",
  "answer": "Der Gemüsehobel eignet sich besonders gut für Hobby- und Heimköche — die extrascharfen Klingen ermöglichen präzises, müheloses Schneiden …",
  "source": "freetext",
  "scrapedAt": "2026-08-19T15:00:00.000000+00:00"
}
```

```json
{
  "type": "asin",
  "asin": "B00008XF6W",
  "marketplace": "de",
  "rufusStatus": "ok",
  "rufusAvailable": true,
  "productTitle": "Fackelmann Gemüsehobel – 29 x 12,5 cm …",
  "suggestedQuestions": ["Wie groß ist der Gemüsehobel?", "Ist er spülmaschinenfest?"],
  "questionsAsked": 3,
  "answersReceived": 3,
  "scrapedAt": "2026-08-19T15:00:00.000000+00:00"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
|---|---|
| `type` | `answer` (charged), `asin` (metadata), or `status` (transparency) |
| `question` | The question exactly as asked (yours or the clicked suggestion chip) |
| `answer` | Rufus' verbatim answer text |
| `source` | `freetext` (your question) or `chip` (Amazon's suggestion) |
| `suggestedQuestions` | Amazon's suggestion chips for the product (on the `asin` item) |
| `rufusStatus` | `ok`, `partial`, `no_answers`, `no_suggestions`, `widget_absent`, `open_failed`, or `unavailable` |
| `reason` / `detail` | Why an ASIN delivered nothing (transparency items) |

### Pricing

Pay-per-event: you are charged **per answer actually pushed** (event `answer`). Everything else is free — the per-ASIN metadata item, and every transparency item for ASINs where Rufus has no widget, a question failed, or the backend was unavailable. A typical run of 10 ASINs × 3 questions yields up to 30 charged answers, minus honest gaps.

### Tips and limitations

> **Beta — honest limitations.** This Actor runs on **logged-in Amazon sessions operated by the publisher** (Rufus answers only exist for logged-in users; anonymous access is server-side blocked by Amazon). It supports **amazon.de, amazon.es, amazon.it, amazon.fr and amazon.com** (all five live-verified 2026-08-19; per-marketplace rollout quota and throttling limits are still unknown, so conservative caps apply), and a run takes **minutes, not seconds** (a real browser session loads the product page and waits for each streamed answer). Rufus answers are LLM-generated and **non-deterministic in wording** — monitor claims and topics, never diff exact wording.

- **Latency is minutes per ASIN.** A real browser session loads the product page, opens the Rufus panel, and waits for each answer to finish streaming. Batch your ASINs into one run.
- **Non-deterministic answers.** Rufus is an LLM; wording varies between identical questions. Normalize to claims/topics for monitoring; never alert on wording diffs.
- **Five verified marketplaces.** Rufus behaves differently per marketplace and is live-verified on amazon.de, amazon.es, amazon.it, amazon.fr and amazon.com (2026-08-19; note: on amazon.com the same widget is branded "Alexa" in the UI). Per-marketplace rollout quota and throttling limits are still unknown — the Actor rejects other marketplaces honestly instead of returning garbage, and more locales follow only after verification.
- **Suggestion chips can be flaky.** Amazon sometimes renders no suggestion chips at all (rollout- and time-dependent) — the run then returns an honest, uncharged `no_suggestions` item. For dependable monitoring, prefer your own free-text questions: they don't depend on chips.
- **Conservative caps.** Max 5 questions per ASIN (default 3). Chat traffic is a stronger account signal than page views; the caps protect the session backend. Jobs are serialized per marketplace on a dedicated account.
- **No anonymous mode.** Rufus is server-side gated to logged-in sessions — there is no anonymous fallback, and the Actor will not pretend otherwise.

### FAQ, disclaimers, and support

**Is this legal?** The Actor reads information shown to a logged-in user and automates no purchases, reviews, or account actions. You are responsible for complying with Amazon's terms and applicable law for your use case.

**Why did my ASIN return `widget_absent`?** Amazon rolls the Rufus widget out per product and audience. Some PDPs simply don't show it — that's a finding, not a bug, and it's never charged.

**Why `no_answers`?** The widget was present, but no answer turn appeared in time (streaming stall). Uncharged; retrying later usually helps.

Feedback and issues: use the **Issues** tab. Custom question sets, additional marketplaces, or higher-volume tiers are available on request.

# Actor input Schema

## `asins` (type: `array`):

Amazon Standard Identification Numbers (10 chars) to ask Rufus about. Either ASINs or product URLs must be provided.

## `productUrls` (type: `array`):

Amazon product URLs (/dp/..., /gp/product/...). ASINs are extracted automatically.

## `marketplace` (type: `string`):

Amazon marketplace. Rufus is verified on logged-in sessions for amazon.de, amazon.es, amazon.it, amazon.fr and amazon.com (live-verified 2026-08-19; per-marketplace rollout quota and throttling limits are still unknown, so conservative caps apply). Other marketplaces are rejected — no anonymous fallback exists; Rufus is server-side gated to logged-in sessions.

## `questions` (type: `array`):

Your own questions, asked verbatim per ASIN as free text (max 5 per ASIN, 300 chars each). Leave EMPTY to click Amazon's own suggestion chips instead — recommended for AI-visibility monitoring of what Amazon suggests.

## `maxQuestionsPerAsin` (type: `integer`):

Upper bound of questions asked (and answers pushed/charged) per ASIN. Conservative default: Rufus chat traffic is a stronger account signal than page views, so the backend caps this hard at 5.

## `sessionBackendUrl` (type: `string`):

Base URL of the publisher-operated scraper API that holds the logged-in Amazon sessions (e.g. an https tunnel to the backend). Leave empty to run without a backend — every ASIN then returns an uncharged 'unavailable' transparency item. Beta: during the publisher-run beta this is preconfigured for invited users.

## `sessionBackendToken` (type: `string`):

Bearer token for the session backend API. Required when a backend URL is set.

## `sessionBackendBasicAuth` (type: `string`):

Optional 'user:password' credentials for an additional HTTP basic-auth layer in front of the backend (e.g. tunnel protection). Leave empty when not needed.

## Actor input object example

```json
{
  "asins": [
    "B00008XF6W"
  ],
  "marketplace": "de",
  "maxQuestionsPerAsin": 3,
  "sessionBackendUrl": ""
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "asins": [
        "B00008XF6W"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cyprusapi/amazon-rufus").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "asins": ["B00008XF6W"] }

# Run the Actor and wait for it to finish
run = client.actor("cyprusapi/amazon-rufus").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "asins": [
    "B00008XF6W"
  ]
}' |
apify call cyprusapi/amazon-rufus --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cyprusapi/amazon-rufus"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ktdm6Y4Dazskaxmqg/builds/cEzwpX22kCAJSHG8Z/openapi.json