# Amazon Wishlist & Registry Scraper (`dataspryva/amazon-wishlist-and-registry-scraper`) Actor

Scrape public/shareable Amazon wishlists, gift lists, baby registries, and wedding registries from URLs you supply. Get list metadata, item ASINs, prices, quantities needed/purchased, priority, and comments.

- **URL**: https://apify.com/dataspryva/amazon-wishlist-and-registry-scraper.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Wishlist & Registry Scraper

Scrape **public and shareable Amazon wishlists, gift lists, baby registries, and wedding registries** from URLs or bare wishlist IDs. Get list metadata (owner/title, description, event date, item counts) and per-item details — ASIN, title, price, quantity needed/purchased, priority, rating, and comments. This actor never searches for or enumerates people's lists; it only visits the exact URL(s) or ID(s) you provide.

### What this actor does

- **Two input modes** — paste full list URLs (`listUrls`) or bare wishlist IDs (`listIds` + `marketplace`)
- **Every current Amazon list URL shape** — `/hz/wishlist/ls/<ID>`, the mobile `/gp/aw/ls?lid=<ID>`, `/gp/registry/wishlist/<ID>`, `/baby-reg/<name>/<ID>`, `/wedding/guest-view/<ID>` (and the older `/wedding/<name>/registry/<ID>`), and `/registries/gl/guest-view/<ID>`
- **Classifies access before extracting anything** — every list is tagged `PUBLIC`, `SHAREABLE`, `PRIVATE_OR_AUTH_REQUIRED`, `NOT_FOUND`, or `BLOCKED`; private/deleted lists return zero item records, never a fake empty "success"
- **Full pagination** — follows Amazon's own "See More" pages until the list ends or `maxItems` is reached, so long lists are not silently truncated at the first screen
- **Real quantities, not guesses** — `requestedQuantity` ("Needs N") and `purchasedQuantity` ("Has N") are separate, real fields
- **Registry metadata** — baby/wedding/Gift List records include the real displayed event/arrival date and city-level event location, plus Amazon's own purchased-item count when shown
- **Empty fields are omitted** — never a `null`/placeholder value

### Privacy — please read

This actor only scrapes the exact URL(s) or wishlist ID(s) you supply. It does not crawl Amazon's registry search to discover or enumerate people or lists. It never infers or exposes a delivery address. Only use it on lists that are genuinely public or explicitly shared with you.

**Credential-free by design.** No cookies, logins, API keys, or tokens are accepted or stored. A private list is reported honestly as `PRIVATE_OR_AUTH_REQUIRED`; the actor cannot open it.

**Registry search is not supported** — Amazon's public "Find a registry" search (`/registries/search`) redirects anonymous visitors to a sign-in page. That is a confirmed Amazon-side gate, not an actor limitation that extra code can bypass. Use the direct registry link instead.

### Output: per-list record (`recordType: "list"`)

- `listId` — the wishlist/registry ID parsed from the URL or supplied in `listIds`
- `type` — `wishlist` / `giftList` / `babyRegistry` / `weddingRegistry` / `customRegistry`
- `title`, `ownerName` — the list/registry display name (only when Amazon shows it publicly)
- `description` — the owner-written description, when the list shows one
- `eventDate` — baby arrival/due date or registry event date, ISO `YYYY-MM-DD`, when displayed
- `eventLocation` — city/state only (never a street address, unit, or postal code)
- `declaredItemCount` — Amazon's own displayed item total, when shown
- `purchasedItemCount` — Amazon's own "N/M items purchased" count, when shown
- `extractedItemCount` — how many item records this run produced
- `accessClassification` — `PUBLIC`, `SHAREABLE`, `PRIVATE_OR_AUTH_REQUIRED`, `NOT_FOUND`, or `BLOCKED`
- `sourceUrl`, `canonicalUrl` — the URL you supplied and the final resolved URL
- `marketplace` — `{countryCode, domain, currency, language}`
- `recordType: "list"`, `scrapedAt`

### Output: per-item record (`recordType: "listItem"`)

- `listId`, `listItemId` — Amazon's own stable per-item ID (classic wishlist `data-itemid`, Gift List entry UUID, a wedding-registry card's ASIN, or the entry UUID of a wedding gift-fund card)
- `position` — 1-based position in the list as scraped (output order may differ for price sorts)
- `asin`, `title`, `url`, `imageUrl`, `brand`
- `price`, `listPrice` — `{value, currency, display}`, only when Amazon shows a parseable amount
- `rating`, `ratingsCount` — only when the item shows a rating
- `requestedQuantity` — "Needs N"/"N of M purchased" requested count
- `purchasedQuantity` — "Has N"/purchased count
- `priority` — `high`/`medium`/`low`, `Most Wanted` (Gift List), or `Must Have` (baby registry), only when the owner/badge sets one
- `comment` — the owner's note, when present
- `variant` — selected size/color/style text, when shown
- `availabilityText`, `discountText` — raw availability/discount text, when shown
- `badge` — real status badge (`{label, category}`), e.g. `{"label": "Best Seller", "category": "in Packing Tape"}`
- `isIdea` — `true` only for a free-text "idea" entry with no linked product (no `asin`/`url`/`imageUrl`)
- `listUrl`, `marketplace`
- `recordType: "listItem"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `listUrls` | array | – | Public/shareable list URLs (any supported Amazon list/registry shape) |
| `listIds` | array | – | Bare wishlist IDs, opened on the selected marketplace |
| `marketplace` | select | `amazon.com` | Marketplace used to build URLs from `listIds` (23 Amazon domains) |
| `maxItems` | integer | `100` | Max items per list (1–10,000); pagination stops at this cap or the real end of the list |
| `sortBy` | select | list default | `date-added` / `priority` / `price-asc` / `price-desc` / `custom` for wishlists |
| `proxyConfiguration` | object | AUTO | Apify proxy; the actor escalates automatically only if Amazon blocks the request |

#### Example: scrape a public wishlist

```json
{
  "listUrls": ["https://www.amazon.com/hz/wishlist/ls/2PBHI0DGWAAAF"],
  "maxItems": 100
}
```

#### Example: IDs mode across two marketplaces

```json
{
  "listIds": ["2PBHI0DGWAAAF"],
  "marketplace": "amazon.co.uk",
  "maxItems": 50
}
```

#### Example: baby registry and wedding registry

```json
{
  "listUrls": [
    "https://www.amazon.com/baby-reg/example-name/EXAMPLEID123",
    "https://www.amazon.com/wedding/guest-view/EXAMPLEID456"
  ],
  "maxItems": 200
}
```

#### Example: a Gift List (school supply drive / birthday list)

```json
{
  "listUrls": ["https://www.amazon.com/registries/gl/guest-view/EXAMPLEID123"],
  "maxItems": 50
}
```

### Use cases

- **Charity and hospital donation drives** — export a shared wishlist so volunteers see current needs
- **Classroom supply lists** — track what teachers still need, including requested vs purchased counts
- **Wedding/baby registry gift coordination** — see remaining needs and the registry's event date
- **Gift-list price monitoring** — watch current prices and rating changes on a shared list
- **Archiving a list you own or administer** — export it before editing or deleting it

### FAQ

**Can this actor find someone's wishlist for me?** No. It only opens URLs or wishlist IDs you provide. Amazon's public registry search requires sign-in, and this actor never enumerates people.

**What happens with a private or deleted list?** You get a list record with `accessClassification: "PRIVATE_OR_AUTH_REQUIRED"` or `"NOT_FOUND"` and zero item records — never a fake "0 items, success" result.

**What does `BLOCKED` mean?** Every retry, including the automatic residential fallback, hit an Amazon anti-bot/CAPTCHA page instead of the list. The list may exist; re-run later. It is never reported as `NOT_FOUND`.

**Does it show delivery addresses?** No. It never infers or exposes a delivery address. Registry event locations are reduced to city/state and street-like text is refused.

**Why is my price in a different currency than the marketplace?** Amazon renders cross-border prices in the visitor's local currency (for example, a US registry viewed from Pakistan can show `PKR`). The `price.currency` field reports the currency Amazon actually displayed; `marketplace.currency` reports the list's own marketplace currency.

**Why are some items missing?** Classic wishlists hide items the owner marked as purchased (the public page only offers an "Unpurchased" filter); some registries hide purchased items the same way. Gift-fund/contribution entries and deleted items may have no product card at all. When a gift-fund card does render, it is returned with its displayed name and a stable entry ID, but with no fabricated ASIN, product URL, or price. Amazon's own counters can therefore be higher than `extractedItemCount`.

**Why are some fields missing on some items?** Amazon only shows priority labels, comments, ratings, variants, and availability text when the owner or product has that data. Fields are included only with real evidence.

**Why does an item have no `asin`/`url`/`imageUrl`?** It is a free-text "idea" entry with no linked product (`isIdea: true`). This is distinct from an extraction gap.

**Can I scrape my own private list?** No. This actor is credential-free and does not accept a session cookie. Set the list to public/shareable and use its link.

**How many items can I get per list?** Up to `maxItems` (maximum 10,000). Long lists are followed through Amazon's own pagination pages, not just the first screen.

**Is `sortBy` honored on every list type?** `date-added`, `priority`, `price-asc`, `price-desc`, and `custom` map to the live wishlist sort control. Registry pages expose their own fixed sort sets; an unsupported value falls back to the list's default order. For price sorts, the actor re-sorts the parsed prices in Python so the output is strictly monotonic even when Amazon's DOM order is not.

**Why is a non-English marketplace showing English or native-language text?** The actor requests Amazon's English cross-border view. Some marketplaces (confirmed: Germany, Japan) honor it; others (confirmed: Turkey; likely Saudi Arabia/Sweden/UAE/Egypt) render natively. Titles/comments may be English or native; prices, ratings, ASINs, and URLs remain correct. Machine-translation is never fabricated.

**What if I supply the same list twice?** It is fetched and returned once, even when the duplicate is a different URL form (exact, mobile `lid=`, or share-ref variant) of the same underlying list.

# Actor input Schema

## `listUrls` (type: `array`):

Direct, public/shareable Amazon list URLs. Accepted shapes: `/hz/wishlist/ls/<ID>`, the mobile `/gp/aw/ls?lid=<ID>`, `/gp/registry/wishlist/<ID>`, `/baby-reg/<name>/<ID>`, `/wedding/guest-view/<ID>` (or `/wedding/<name>/registry/<ID>`), and `/registries/gl/guest-view/<ID>`. This actor never searches for or enumerates lists; it only visits the exact URLs you provide.

## `listIds` (type: `array`):

Bare wishlist IDs copied from a list URL (for example `2PBHI0DGWAAAF` from `/hz/wishlist/ls/2PBHI0DGWAAAF`). Each ID is opened on the marketplace selected below. Use this instead of `listUrls` when you only have the ID.

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

Amazon marketplace used to build URLs from `listIds`. Ignored for `listUrls` because each URL already carries its own marketplace.

## `maxItems` (type: `integer`):

Hard cap on the number of list items scraped per list URL. The full list is followed through Amazon's own pagination until this cap is reached or the list ends.

## `sortBy` (type: `string`):

Sort order for wishlist items, matching the sort control shown on the live wishlist page. Registry pages expose their own fixed sort set; unsupported values fall back to the list's default order.

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

Apify proxy used to fetch list pages. Defaults to the free AUTO (datacenter) group; the actor escalates to a residential session automatically only if a block is detected.

## Actor input object example

```json
{
  "listUrls": [
    "https://www.amazon.com/hz/wishlist/ls/2PBHI0DGWAAAF"
  ],
  "marketplace": "amazon.com",
  "maxItems": 20,
  "sortBy": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped list records and their item records.

# 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 = {
    "listUrls": [
        "https://www.amazon.com/hz/wishlist/ls/2PBHI0DGWAAAF"
    ],
    "marketplace": "amazon.com",
    "maxItems": 20,
    "sortBy": "",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/amazon-wishlist-and-registry-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 = {
    "listUrls": ["https://www.amazon.com/hz/wishlist/ls/2PBHI0DGWAAAF"],
    "marketplace": "amazon.com",
    "maxItems": 20,
    "sortBy": "",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/amazon-wishlist-and-registry-scraper").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 '{
  "listUrls": [
    "https://www.amazon.com/hz/wishlist/ls/2PBHI0DGWAAAF"
  ],
  "marketplace": "amazon.com",
  "maxItems": 20,
  "sortBy": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dataspryva/amazon-wishlist-and-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/amazon-wishlist-and-registry-scraper"
        }
    }
}
```

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/x5uIAjSyeZfnCa4v7/builds/4U8HxHY1EyImWcyfY/openapi.json