# Amazon Influencer Storefront Scraper (`automation-lab/amazon-influencer-storefront-scraper`) Actor

👤 Extract public Amazon creator profiles, idea lists, curations, social links, and recommended ASINs into separate datasets for influencer research.

- **URL**: https://apify.com/automation-lab/amazon-influencer-storefront-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Amazon Influencer Storefront Scraper

Extract public Amazon creator profiles, idea lists, curations, and recommended products from storefront URLs.

Use **Amazon Influencer Storefront Scraper** to connect a creator identity to the collections and ASINs visible on their public Amazon page.
The Actor runs without Amazon login credentials and saves clean profile, collection, and product datasets.

### What does Amazon Influencer Storefront Scraper do?

The Actor accepts URLs such as `https://www.amazon.com/shop/sydneydelrey`.
It reads the public storefront and returns:

- 👤 Creator handle, display name, biography, avatar, marketplace, and social links
- 📋 Public idea-list titles, IDs, URLs, images, and advertised item counts
- 🎬 Public curation titles, IDs, URLs, images, and post counts
- 📦 Visible product ASINs, brands, titles, images, links, and price or availability text
- 🕒 A `scrapedAt` timestamp on every record for monitoring and comparison

You can also submit a direct `/shop/{handle}/list/{id}` URL to target one idea list.

### Who is it for?

#### Influencer marketing agencies

Build creator shortlists, inspect creator-to-product fit, and export storefront evidence for campaign planning.

#### Amazon brands and marketplace teams

Find which public creators recommend an ASIN, review adjacent brands in the same list, and monitor assortment changes.

#### Affiliate and partnership managers

Qualify creators from their public biography, social links, list themes, and visible product mix before outreach.

#### Creator-commerce researchers

Create repeated snapshots for creator economy, category, product placement, or social-commerce analysis.

#### Developers and data teams

Feed normalized profiles, collections, and ASINs into a warehouse, CRM, dashboard, alert, or enrichment pipeline.

### Why use this Amazon influencer scraper?

Manually opening storefronts and copying products is slow and inconsistent.
This Actor provides a repeatable public-data workflow:

- ✅ Batch several storefront URLs in one run
- ✅ Keep three entity types in separate typed datasets
- ✅ Deduplicate profiles, collections, and ASINs within a run
- ✅ Bound collection and product volume for predictable runs
- ✅ Retry temporary Amazon responses with exponential backoff
- ✅ Add Apify Proxy settings only when a marketplace needs them
- ✅ Export JSON, CSV, Excel, XML, RSS, or JSONL from Apify

### What data can I extract?

| Dataset | Important fields | Typical use |
|---|---|---|
| Creator profiles | `handle`, `name`, `description`, `avatarUrl`, `socialLinks`, `marketplace` | Creator qualification and outreach enrichment |
| Collections | `collectionType`, `collectionId`, `title`, `collectionUrl`, `itemCount` | Content-theme and assortment analysis |
| Products | `asin`, `brand`, `title`, `productUrl`, `imageUrl`, `priceText` | Product placement, competitor, and campaign research |

Fields that Amazon does not show publicly are omitted.
For example, `priceText` is optional because some product cards show availability language instead of a price.

### Multiple datasets

The Actor creates three datasets because profiles, collections, and products have different shapes.

1. **Creator profiles** use the run's default dataset.
2. **Idea lists and curations** use the `collections` dataset alias.
3. **Recommended products** use the `products` dataset alias.

Open the run's **Storage** tab to choose and export each dataset.
The main run output also links directly to all three.
This structure avoids mixed rows and makes downstream schema validation easier.

### How to scrape an Amazon influencer storefront

1. Open the Actor input page.
2. Add one or more public Amazon `/shop/` URLs.
3. Keep **Extract recommended products** enabled if ASINs are needed.
4. Choose a small collection and product limit for the first run.
5. Click **Start**.
6. Review Creator profiles, Collections, and Products in the output.
7. Export the dataset you need or access it through the API.

A small first run with one creator, three collections, and eight products per list is a useful validation workflow.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/shop/sydneydelrey" }
  ],
  "scrapeProducts": true,
  "maxCollectionsPerStorefront": 3,
  "maxProductsPerCollection": 8,
  "requestRetries": 2
}
````

#### Input fields

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Public Amazon storefront or direct idea-list URLs |
| `scrapeProducts` | boolean | `true` | Fetch visible product cards from selected idea lists |
| `maxCollectionsPerStorefront` | integer | `5` | Save at most this many lists and curations per creator |
| `maxProductsPerCollection` | integer | `16` | Save up to 16 server-rendered products per idea list |
| `requestRetries` | integer | `2` | Retry temporary or blocked responses with backoff |
| `proxyConfiguration` | object | direct HTTP | Optional Apify Proxy settings |

### Output examples

#### Creator profile

```json
{
  "handle": "sydneydelrey",
  "name": "sydney del rey",
  "description": "sharing all of my favorite Amazon finds ...",
  "storefrontUrl": "https://www.amazon.com/shop/sydneydelrey",
  "marketplace": "www.amazon.com",
  "collectionCount": 21,
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

#### Collection

```json
{
  "handle": "sydneydelrey",
  "collectionType": "idea_list",
  "collectionId": "KUGNMP73CKST",
  "title": "vacay fitspo (from videos)",
  "itemCount": 254,
  "collectionUrl": "https://www.amazon.com/shop/sydneydelrey/list/KUGNMP73CKST"
}
```

#### Product

```json
{
  "handle": "sydneydelrey",
  "collectionId": "KUGNMP73CKST",
  "asin": "B0GS5LX63J",
  "brand": "Muineobuka",
  "title": "Backless Halter Tops for Women ...",
  "productUrl": "https://www.amazon.com/dp/B0GS5LX63J"
}
```

Examples show the output shape, not a promise that any creator or item remains unchanged.

### How much does it cost to scrape Amazon influencer storefronts?

The Actor uses pay-per-event pricing. A **$0.005 Start** charge covers run initialization, then an Item charge applies to every profile, collection, or product record saved.

| Apify tier | Price per record |
|---|---:|
| Free | $0.000079721 |
| Bronze | $0.000069323 |
| Silver | $0.000054072 |
| Gold | $0.000041594 |
| Platinum | $0.000027729 |
| Diamond | $0.00001941 |

At the Bronze rate, 1,000 profile, collection, or product records cost about **$0.0693**, plus the Start charge.
You can control cost with `maxCollectionsPerStorefront`, `maxProductsPerCollection`, and `scrapeProducts`.
No Amazon account or paid third-party API key is required.

### Monitoring creator-to-ASIN changes

Run the same input on a schedule and compare `asin` plus `collectionId` between snapshots.
Useful alerts include:

- 🆕 A creator adds a target brand or ASIN
- 🗑️ A previously visible ASIN disappears
- 📈 An idea list's advertised item count changes
- 🏷️ A creator launches a new category-themed list
- 🔗 A creator adds or changes a public social profile

Store snapshots in a named dataset, database, spreadsheet, or data warehouse outside this Actor when long-term history is required.

### Integrations

#### Google Sheets

Schedule the Actor, export the Products dataset, and append new creator-to-ASIN rows for campaign research.

#### Slack or email alerts

Use an Apify webhook after each run, compare against the previous snapshot, and notify a partnership channel when target products appear.

#### CRM enrichment

Join creator handles and public social links to CRM records before partnership outreach.

#### Data warehouse

Load profiles, collections, and products as separate tables keyed by `handle`, `collectionId`, and `asin`.

#### Zapier and Make

Trigger the Actor from a no-code workflow and route completed dataset exports to Sheets, Airtable, or messaging tools.

### API usage: run with the Apify API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/amazon-influencer-storefront-scraper').call({
  startUrls: [{ url: 'https://www.amazon.com/shop/sydneydelrey' }],
  scrapeProducts: true,
  maxCollectionsPerStorefront: 3,
  maxProductsPerCollection: 8,
});
console.log(run.id);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/amazon-influencer-storefront-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.amazon.com/shop/sydneydelrey'}],
    'scrapeProducts': True,
    'maxCollectionsPerStorefront': 3,
    'maxProductsPerCollection': 8,
})
print(run['id'])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~amazon-influencer-storefront-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.amazon.com/shop/sydneydelrey"}],"maxCollectionsPerStorefront":3,"maxProductsPerCollection":8}'
```

### Use with Apify MCP

Connect AI clients through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/amazon-influencer-storefront-scraper).

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/amazon-influencer-storefront-scraper"
```

#### Claude Desktop and Cursor

Add the server to Claude Desktop's or Cursor's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/amazon-influencer-storefront-scraper"
    }
  }
}
```

#### VS Code

Use the same Apify MCP URL in VS Code's MCP server settings and authenticate with your Apify account.

Example prompts:

- “Extract the profile and first three lists from this Amazon influencer storefront.”
- “Return the visible ASINs from this creator's idea-list URL.”
- “Compare these creator storefronts and group recommended products by brand.”

### Tips for reliable runs

- Start with one creator and low limits.
- Use a direct idea-list URL when only one list matters.
- Keep retries enabled for temporary Amazon response variation.
- Add an Apify Proxy configuration if direct access is limited for a marketplace.
- Avoid unnecessary high concurrency; public storefront pages are the source of truth.
- Treat price as optional and use the product URL for current product details.
- Inspect logs if a creator renamed or removed a public storefront.

### Supported URLs and marketplaces

The Actor accepts public URLs matching `/shop/{handle}` on common Amazon marketplaces, including the US, Canada, Mexico, Brazil, UK, Germany, France, Italy, Spain, Netherlands, Sweden, Poland, Belgium, Japan, India, Australia, Singapore, Turkey, UAE, and Saudi Arabia.

The marketplace is inferred from each URL.
Markup and field availability can vary by domain and geography.
A successful US test does not guarantee that every creator has an equivalent storefront on every marketplace.

### Limitations

- Amazon currently server-renders up to 16 visible product cards on an idea-list page; v1 intentionally caps extraction at that amount.
- Curations are saved as collection metadata; products inside video/photo curation feeds are not expanded in v1.
- Prices, discounts, delivery text, badges, and availability vary by session and region.
- Private dashboards, commission data, buyer data, and Associates account data are not accessed.
- Removed, renamed, geo-limited, or challenged storefronts can fail explicitly.
- Amazon can change public markup, so stable IDs and URL fallbacks are used but future maintenance may be needed.

### Legality: is it legal to scrape Amazon influencer storefronts?

This Actor extracts information visible on public storefront pages.
Public availability does not remove every legal or contractual obligation.
You are responsible for your use case, local law, Amazon's applicable terms, intellectual-property rights, and personal-data requirements.

Use the data for legitimate research, analysis, interoperability, or monitoring.
Do not use the Actor to access private accounts, circumvent authentication, impersonate people, harass creators, or send unlawful unsolicited messages.
Store only the data you need and honor valid deletion or restriction obligations.

### Troubleshooting

#### The run says the storefront was not accessible

Verify that the URL opens publicly and follows `/shop/{handle}`.
The creator may have renamed, removed, or geo-limited the page.
Retry later or configure Apify Proxy for the target marketplace.

#### I received a profile but no products

Confirm `scrapeProducts` is `true` and that selected collections include idea lists.
Curations can contain posts rather than server-rendered product cards.
Try a direct idea-list URL if you know the target list.

#### Some products have no price

Amazon does not display a numeric price on every public card.
The Actor keeps `priceText` nullable and can return `availabilityText` instead.
Use `productUrl` or a dedicated product scraper for current product detail enrichment.

#### Where are collections and products?

Open the run's Storage tab and select the `collections` or `products` dataset.
The default dataset contains creator profiles.

### Related Amazon scrapers

- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper) — enrich ASINs with current product details.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — analyze customer feedback for recommended products.
- [Amazon Seller Scraper](https://apify.com/automation-lab/amazon-seller-scraper) — inspect sellers behind marketplace offers.

Use this Actor when the key relationship is **creator → collection → product**.
Use a product, review, or seller Actor when deeper marketplace entity data is the primary goal.

### FAQ: frequently asked questions

#### Does this require an Amazon login?

No. The Actor is designed for anonymous public storefront and idea-list pages.

#### Can I scrape multiple creators in one run?

Yes. Add multiple storefront URLs to `startUrls` and keep bounded limits for predictable duration.

#### Can I target one idea list?

Yes. Submit its full `/shop/{handle}/list/{id}` URL.

#### Does it find influencer storefronts by keyword?

No. V1 extracts known public storefront URLs; it does not claim to provide Amazon-wide creator discovery.

#### Are results real-time?

Each run reads the public pages available at run time and adds `scrapedAt` timestamps.

#### Can I use the data in an AI workflow?

Yes. Typed schemas, separate datasets, API access, and Apify MCP make the output suitable for agent and data workflows.

### Data quality notes

Identifiers come from Amazon's public URLs and content attributes.
Products are deduplicated by ASIN within each requested collection.
Collections are deduplicated by type and Amazon collection ID.
Repeated duplicate input URLs are processed once per run.

The Actor fails when it cannot identify a public storefront rather than silently returning an empty successful run.
That behavior helps scheduled monitors distinguish “no change” from “source unavailable.”

# Actor input Schema

## `startUrls` (type: `array`):

Public URLs such as https://www.amazon.com/shop/sydneydelrey. Direct /list/ URLs limit extraction to that idea list.

## `scrapeProducts` (type: `boolean`):

Open each selected idea list and save its visible ASINs, titles, brands, images, and public price or availability text.

## `maxCollectionsPerStorefront` (type: `integer`):

Maximum idea lists and curations saved from each storefront. Keep this low for quick monitoring runs.

## `maxProductsPerCollection` (type: `integer`):

Maximum server-rendered products saved from each idea list. Amazon currently exposes up to 16 on the public list page.

## `requestRetries` (type: `integer`):

Retries blocked or temporary responses with exponential backoff and a fresh proxy session when a proxy is configured.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Direct HTTP is used when omitted; add a proxy if Amazon blocks your target marketplace.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/shop/sydneydelrey"
    }
  ],
  "scrapeProducts": true,
  "maxCollectionsPerStorefront": 3,
  "maxProductsPerCollection": 8,
  "requestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

No description

## `collections` (type: `string`):

No description

## `products` (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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/shop/sydneydelrey"
        }
    ],
    "scrapeProducts": true,
    "maxCollectionsPerStorefront": 3,
    "maxProductsPerCollection": 8,
    "requestRetries": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/amazon-influencer-storefront-scraper").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 = {
    "startUrls": [{ "url": "https://www.amazon.com/shop/sydneydelrey" }],
    "scrapeProducts": True,
    "maxCollectionsPerStorefront": 3,
    "maxProductsPerCollection": 8,
    "requestRetries": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/amazon-influencer-storefront-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/shop/sydneydelrey"
    }
  ],
  "scrapeProducts": true,
  "maxCollectionsPerStorefront": 3,
  "maxProductsPerCollection": 8,
  "requestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/amazon-influencer-storefront-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/amazon-influencer-storefront-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Influencer Storefront Scraper",
        "description": "👤 Extract public Amazon creator profiles, idea lists, curations, social links, and recommended ASINs into separate datasets for influencer research.",
        "version": "0.1",
        "x-build-id": "KVfCClcBcbzAPJhER"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~amazon-influencer-storefront-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-amazon-influencer-storefront-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-influencer-storefront-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-amazon-influencer-storefront-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~amazon-influencer-storefront-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-amazon-influencer-storefront-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Amazon storefront URLs",
                        "type": "array",
                        "description": "Public URLs such as https://www.amazon.com/shop/sydneydelrey. Direct /list/ URLs limit extraction to that idea list.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeProducts": {
                        "title": "Extract recommended products",
                        "type": "boolean",
                        "description": "Open each selected idea list and save its visible ASINs, titles, brands, images, and public price or availability text.",
                        "default": true
                    },
                    "maxCollectionsPerStorefront": {
                        "title": "Maximum collections per storefront",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum idea lists and curations saved from each storefront. Keep this low for quick monitoring runs.",
                        "default": 5
                    },
                    "maxProductsPerCollection": {
                        "title": "Maximum products per idea list",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Maximum server-rendered products saved from each idea list. Amazon currently exposes up to 16 on the public list page.",
                        "default": 16
                    },
                    "requestRetries": {
                        "title": "Request retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retries blocked or temporary responses with exponential backoff and a fresh proxy session when a proxy is configured.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct HTTP is used when omitted; add a proxy if Amazon blocks your target marketplace."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```