# AbeBooks Scraper \[From $1.5💰] | Book Prices | Arbitrage (`ahmed_jasarevic/abebooks-scraper`) Actor

Extract AbeBooks listings with prices, condition, shipping and seller data for book price comparison, arbitrage sourcing and textbook price monitoring. Structured rows ready for reseller workflows, CSV export and recurring runs.

- **URL**: https://apify.com/ahmed_jasarevic/abebooks-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 results

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/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

## AbeBooks Scraper

Scrape book listings from **AbeBooks.com** — the world's largest online marketplace for used, rare, and out-of-print books — into **43 structured fields per listing**, from price, shipping and condition to seller star rating and Goodreads score. The **AbeBooks scraper** for book arbitrage, textbook price monitoring and ISBN price lookup, with pay-per-event pricing and 10 free items per run.

### Use Cases: Book Arbitrage, Textbook Arbitrage and Resale Sourcing

- **Book price comparison & ISBN price lookup** — search by ISBN and pull every seller's offer: price, shipping with delivery windows, condition and quantity in one row.
- **Book arbitrage and reselling** — find underpriced copies by filtering on price, condition and seller rating, add `shippingPrice` for landed cost, then resell books for profit.
- **Textbook arbitrage & price tracking** — track course-book ISBNs, watch for price drops and restocks, schedule recurring runs in term season.
- **Rare book valuation** — search by author, keyword, year range and condition to compare live listings across editions and bindings.
- **Out-of-print and collectible sourcing** — keyword/author/title/year filters surface hard-to-find copies.
- **Cross-border price checks** — 11 currencies and 27 ship-to countries show what a listing costs delivered (AbeBooks international shipping).

### How The AbeBooks Scraper Works

The actor runs plain HTTP requests through Crawlee's `CheerioCrawler` — no browser, no login — reading AbeBooks' Next.js RSC flight payload, which returns every listing as inline JSON from search pages. Opt-in detail enrichment merges extra fields into the same row (never a duplicate row). Requests run in parallel from the first second (`maxConcurrency`, default 40); duplicates across pages are skipped.

### Input Parameters: Search by Keyword, Author, Title or ISBN

Top-level input fields:

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searches` | `SearchQuery[]` | ✅ | `[{ "keyword": "harry potter" }]` | 1–50 queries entered as form rows; each combines multiple filters (table below). |
| `maxPagesPerSearch` | `integer` | | `10` | Search result pages per query (1–50). |
| `maxDetailsPerSearch` | `integer` | | `50` | Detail pages per query (0–200); only used when `enrichDetails` is on. |
| `enrichDetails` | `boolean` | | `false` | Visit each listing's detail page and merge description, page count, edition, ISBN-10, seller details and shipping table into the same row. Charged per detail page via `Listing detail`. Off = search results only. |
| `maxConcurrency` | `integer` | | `40` | Parallel HTTP requests (1–100). |
| `currency` | `enum` | | `USD` | Price/shipping currency (ISO 4217): `USD`, `EUR`, `GBP`, `CAD`, `AUD`, `CHF`, `JPY`, `SEK`, `NOK`, `DKK`, `PLN`. |
| `shipDest` | `enum` | | `US` | Ship-to country (ISO 3166-1 alpha-2), 27 values: `US`, `GB`, `DE`, `FR`, `ES`, `IT`, `NL`, `CA`, `AU`, `NZ`, `IE`, `PT`, `BE`, `AT`, `CH`, `SE`, `NO`, `DK`, `FI`, `PL`, `CZ`, `JP`, `IN`, `BR`, `MX`, `SG`, `ZA` — controls the shipping rates shown. |
| `maxRequestsPerCrawl` | `integer` | | `500` | Hard cap on total HTTP requests across all searches (min 1). |
| `proxy` | `ProxyConfig` | | `{ "useApifyProxy": false }` | Standard Apify proxy config; residential/datacenter selectable in the UI. |

`currency` and `shipDest` are **top-level** settings applied to all queries — they are not per-query fields.

#### SearchQuery Fields (one row per query)

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `keyword` | `string` | | | Free-text keyword (AbeBooks `kn`), e.g. `harry potter`, `first edition`. |
| `author` | `string` | | | Author filter (`an`). |
| `title` | `string` | | | Title filter (`bn`). |
| `isbn` | `string` | | | ISBN-10 or ISBN-13 (`isbn`); hyphens ignored. |
| `publisher` | `string` | | | Publisher filter (`ap`). |
| `condition` | `string` | | | Condition filter (`tn`): `New`, `Used`, `Like New`, `Very Good`, `Good`, `Acceptable`. |
| `minPrice` | `number` | | | Min price in selected currency (`prl`). |
| `maxPrice` | `number` | | | Max price (`prh`). |
| `minYear` | `integer` | | | Earliest publication year (`yrl`). |
| `maxYear` | `integer` | | | Latest publication year (`yrh`). |
| `language` | `string` | | | Language filter (`lang`), e.g. `English`, `German`, `French`, `Spanish`. |
| `sortBy` | `enum` | | `bestMatch` | `bestMatch`, `priceAsc`, `priceDesc`, `newest`, `oldest`, `condition`, `distance`, `quantity`. |

### Output Fields: Price, Shipping, Condition, Seller Rating and Goodreads Score

Each dataset item is **one book listing** with 43 fields. Most are nullable — `null` when AbeBooks does not publish the value.

**Listing & bibliographic (17)**

| Field | Type | Description |
| --- | --- | --- |
| `listingId` | `integer` | Internal listing ID. |
| `vendorListingId` | `string` | Seller's own SKU. |
| `title` | `string` | Book title. |
| `author` | `string` | Author name. |
| `authorUrl` | `string` | Author page URL. |
| `isbn13` | `string` | ISBN-13. |
| `isbn10` | `string` | ISBN-10. |
| `publisher` | `string` | Publisher. |
| `publishYear` | `integer` | Publication year. |
| `language` | `string` | Book language. |
| `edition` | `string` | Edition statement (e.g. `1st Edition`). |
| `binding` | `string` | Binding type (e.g. `Hardcover`, `Paperback`). |
| `pageCount` | `integer` | Page count. |
| `description` | `string` | Seller's description. |
| `bsaCodes` | `string[]` | Book Search Attributes codes (categories/features). |
| `pictureUrls` | `string[]` | Additional images. |
| `imageUrl` | `string` | Primary cover image. |

**Price & shipping (5)**

| Field | Type | Description |
| --- | --- | --- |
| `price` | `number` | Book price in the requested currency. |
| `currency` | `string` | Price currency (ISO 4217). |
| `shippingPrice` | `number` | Shipping cost to the requested destination. |
| `shippingCurrency` | `string` | Shipping price currency. |
| `shippingRates` | `object[]` | All shipping options: `price`, `currency`, `minDeliveryDays`, `maxDeliveryDays`. |

**Condition & availability (4)**

| Field | Type | Description |
| --- | --- | --- |
| `condition` | `string` | Internal condition code (e.g. `USED_VERYGOOD`). |
| `conditionLabel` | `string` | Human-readable condition (e.g. `Very Good`). |
| `quantity` | `integer` | Copies available from this seller. |
| `availability` | `string` | Stock status (e.g. `InStock`). |

**Seller (8)**

| Field | Type | Description |
| --- | --- | --- |
| `sellerName` | `string` | Seller's bookstore name. |
| `sellerId` | `integer` | AbeBooks internal seller ID. |
| `sellerCountry` | `string` | Seller country. |
| `sellerState` | `string` | Seller state/province. |
| `sellerCity` | `string` | Seller city. |
| `sellerStarRating` | `number` | Seller star rating (1–5). |
| `sellerSince` | `string` | Seller join date. |
| `sellerUrl` | `string` | Seller storefront URL. |

**Ratings & links (4)**

| Field | Type | Description |
| --- | --- | --- |
| `goodreadsRating` | `number` | Goodreads average rating. |
| `goodreadsRatingCount` | `integer` | Goodreads rating count. |
| `listingUrl` | `string` | Direct listing detail page (`/bd`). |
| `productUrl` | `string` | Product page (`/plp`) aggregating sellers. |

**Run metadata (5)**

| Field | Type | Description |
| --- | --- | --- |
| `sourceUrl` | `string` | Source search/detail page URL. |
| `source` | `enum` | `search` = search data only; `detail` = enriched from its detail page. One row per listing either way. |
| `currencyRequested` | `string` | Currency requested in the input. |
| `shippingDestinationRequested` | `string` | Ship-to country requested in the input. |
| `scrapedAt` | `datetime` | ISO scrape timestamp. |

#### Dataset views

- **Overview** (default table): `title`, `author`, `price`, `currency`, `conditionLabel`, `sellerName`, `listingUrl` — quick browsing.
- **Arbitrage View**: `isbn13`, `title`, `author`, `price`, `shippingPrice`, `currency`, `conditionLabel`, `sellerName`, `sellerCountry`, `sellerStarRating`, `listingUrl` — landed cost and seller trust per ISBN when sourcing inventory to resell.

### Example Input And Output

#### Example Input

```json
{
    "searches": [
        { "keyword": "textbook biology", "maxPrice": 50, "condition": "Used", "sortBy": "priceAsc" },
        { "isbn": "9780134093413" },
        { "author": "Brandon Sanderson", "title": "Mistborn", "minYear": 2006 }
    ],
    "maxPagesPerSearch": 5,
    "enrichDetails": true,
    "maxDetailsPerSearch": 20,
    "currency": "USD",
    "shipDest": "US",
    "maxRequestsPerCrawl": 200,
    "proxy": { "useApifyProxy": true }
}
```

#### Example Output (truncated)

```json
{
    "listingId": 32439259548,
    "title": "Harry Potter And The Chamber Of Secrets",
    "author": "Rowling, J.K.",
    "isbn13": "9780439064873",
    "isbn10": "0439064872",
    "publisher": "Scholastic Paperbacks",
    "publishYear": 2000,
    "binding": "Paperback",
    "description": "Meets the good condition guidelines. Has some crinkling...",
    "condition": "USED_GOOD",
    "conditionLabel": "Good",
    "quantity": 1,
    "price": 7.89,
    "currency": "USD",
    "shippingPrice": 45.0,
    "shippingRates": [
        { "price": 45.0, "currency": "USD", "minDeliveryDays": 8, "maxDeliveryDays": 36 },
        { "price": 65.0, "currency": "USD", "minDeliveryDays": 7, "maxDeliveryDays": 28 }
    ],
    "sellerName": "Hawking Books",
    "sellerId": 54932187,
    "sellerCountry": "USA",
    "sellerStarRating": 4,
    "sellerUrl": "https://www.abebooks.com/Hawking-Books-Edgewood-TX-U.S.A/54932187/sf",
    "goodreadsRating": 4.42,
    "listingUrl": "https://www.abebooks.com/Harry-Potter-Chamber-Secrets-Rowling-J.K/32439259548/bd",
    "source": "search",
    "scrapedAt": "2026-10-05T12:34:56.789Z"
}
```

### Extract Book Listings, Prices and Seller Data For Arbitrage

- **Search + detail extraction** — keyword/author/ISBN searches, optionally enriched with detail-page data; detail fields merge **into the same row**, never a duplicate row.
- **Full listing data** — title, author, ISBN-10/13, price + shipping, condition, seller name/location/rating, edition, description, binding, page count, publisher, year, language.
- **Arbitrage-ready** — shipping rates with delivery estimates, seller star ratings, Goodreads ratings, quantity available.
- **Currency & destination control** — prices and shipping normalized to your chosen currency and ship-to country.
- **Parallel by default** — concurrent requests from the first second (`maxConcurrency`, default 40).
- **Affiliate-ready rows** — every row carries `listingUrl` and `productUrl` for commission-link feeds.

#### Pricing and limits

Pay-per-event billing: every dataset row charges `Result` ($0.0015); opt-in enrichment charges `Listing detail` ($0.0005) per fetched detail page; `Actor Start` ($0.00005) is charged automatically. Free users get 10 items per run; paid Apify users get unlimited.

| Tier | Items/Run | Memory | Est. Compute Units/1k items |
| --- | --- | --- | --- |
| Free (Apify Free plan) | 10 | 256 MB | ~0.02 CU |
| Paid (Apify paid plan) | Unlimited | 256 MB | ~0.02 CU |

**Typical run:** 1 search × 10 pages × 30 results = 300 items → ~0.006 CU (negligible).

### Build Book Price Data Without Official AbeBooks API Access

The actor uses `CheerioCrawler` (no browser) and exploits AbeBooks' **Next.js App Router RSC (React Server Components) flight payload**:

1. A search page requested with the `RSC: 1` header (sent automatically) returns a `text/x-component` stream instead of the full HTML shell.
2. That stream contains **inline JSON objects** for every listing — `{"listing":{...}}` with price, shipping, seller, condition, ISBN, images and more.
3. The actor parses these payloads directly — **no DOM scraping, no JavaScript rendering, no Cloudflare challenge**.

**Why this wins:**

- **10–50× faster than Playwright** — plain HTTP requests only.
- **Bypasses anti-bot** — the RSC endpoint doesn't serve Cloudflare Turnstile/challenges.
- **Cheaper on Apify** — runs at 256 MB memory (vs 1024+ MB for a browser).
- **Maintainable** — structured JSON is stable; DOM selectors break on redesign.

**Fallback:** if the flight payload is unavailable (rare), the actor falls back to `application/ld+json` structured data embedded in the HTML, then to Cheerio selectors on detail pages.

#### Technical details

- **Crawler**: `CheerioCrawler` (Crawlee)
- **Primary data source**: Next.js RSC flight payload (`text/x-component`)
- **Fallback**: `application/ld+json` (schema.org `ItemList`/`Product`/`Book`)
- **Detail enrichment**: `ld+json` + Cheerio selectors on `/bd` and `/plp` pages
- **Memory**: 256 MB (configured in `.actor/actor.json`)
- **Proxy**: standard Apify proxy input (residential/datacenter selectable in UI)

#### Version history

- **v0.3** — Pay-per-event pricing wired in: every dataset row charges the primary `result` event; event names fixed in code (no input field for them).
- **v0.2** — One row per listing (detail data merges into the search row); detail enrichment opt-in via `enrichDetails`, charged per page; parallel from the first request; form-based queries; duplicates across result pages skipped.
- **v0.1** — Initial release: RSC flight payload extraction, search + detail, full field set.

### Run AbeBooks Scraper From the Apify API, Console Or Schedule

- **Apify REST API** — start runs and read results from the dataset endpoint (`GET /v2/datasets/{datasetId}/items`); small jobs can run synchronously.
- **Webhooks** — push finished rows to your backend or database.
- **Zapier & Make** — trigger no-code workflows from new dataset rows.
- **Console & Tasks** — save the input once as an Actor task so you never reconfigure searches between runs.
- **Schedules** — recurring runs suit monitoring: daily (`@daily`) for textbook price tracking in term season, weekly (`@weekly`) for rare-book and out-of-print watches.

### Integrations & Automation

Native Apify integrations only. **Apify API**: start runs and read results from `GET /v2/datasets/{datasetId}/items`; small searches run synchronously. **Webhooks**: `ACTOR.SUCCEEDED` pushes finished listing rows to your backend or database. **Zapier / Make**: native Apify modules triggered by new dataset rows. **Schedules**: the realistic monitoring pattern is daily (`@daily`) textbook-price runs during term season and weekly (`@weekly`) rare-book and out-of-print watches.

### Related Actors And AbeBooks Alternatives

- [crawlerbros/abebooks-scraper](https://apify.com/crawlerbros/abebooks-scraper) — competing AbeBooks scraper on the Apify Store.
- [lulzasaur/abebooks-scraper](https://apify.com/lulzasaur/abebooks-scraper) — competing AbeBooks used & rare books scraper.
- [automation-lab/abebooks-book-search-listings](https://apify.com/automation-lab/abebooks-book-search-listings) — AbeBooks book-search listings exporter.
- [getascraper/thriftbooks-scraper](https://apify.com/getascraper/thriftbooks-scraper) — ThriftBooks scraper for `thriftbooks vs abebooks` price comparisons.
- [ahmed_jasarevic/goodreads-scraper](https://apify.com/ahmed_jasarevic/goodreads-scraper) — Goodreads books and ratings; pairs with the Goodreads fields in this actor's output.

### AbeBooks Scraper FAQ

#### How can I make money reselling books online?

The common paths are sourcing cheap copies (thrift stores, clearance, bulk lots), doing **textbook arbitrage** around term start, and flipping rare or out-of-print editions. This actor supports the sourcing half: ISBN and keyword searches at scale, `price` + `shippingPrice` comparisons, `conditionLabel` and `sellerStarRating` checks, and scheduled re-runs to catch price drops. It does not buy or sell for you.

#### What is the best API for used book prices and ISBN price data?

For AbeBooks listings, this actor returns price, shipping, condition, seller and Goodreads fields per ISBN as a structured dataset — $0.0015 per row, no AbeBooks affiliation required. Wider options in the category include ISBNdb, SerpApi, BookScouter and Analyzer.Tools, plus AbeBooks' own official route (below). Compare on delivered cost (`price` + `shippingPrice`), condition granularity and seller data.

#### How do I value rare books and first editions?

There is no single number — value comes from comparing live listings: edition and binding, publication year (`minYear`/`maxYear`), physical condition (`conditionLabel` plus the seller's `description`), seller rating, and demand signals like `goodreadsRatingCount`. This actor exposes exactly those fields so you can build a **rare book price database** from current asking prices — a market-data tool, not an appraisal.

#### Is AbeBooks legit and safe to buy used books from?

AbeBooks is a long-running marketplace for used, rare and out-of-print books. The dataset does not ask you to take that on faith: every row includes `sellerStarRating`, `sellerSince`, seller location, `quantity` and `conditionLabel`, so you can judge each offer first.

#### What is book arbitrage and how does it work?

**Book arbitrage** is buying books that are underpriced on one market (or in bulk) and reselling them at a higher price. The loop: find undervalued copies, verify condition and delivered cost, confirm demand, list elsewhere at market price. `online book arbitrage` and `textbook arbitrage` apply the same loop to general stock and semester textbooks. This actor automates the find-and-monitor steps with structured search results.

#### Is it legal to scrape book prices from online marketplaces?

Legality depends on jurisdiction, the source's terms of service and how the data is used; this README gives no legal conclusion. General good practice: respect `robots.txt`, terms of service and rate limits, keep runs proportionate, and use the data for personal or evaluative analysis. This actor only reads publicly available listing pages, has no login, and applies a configurable request cap.

#### Is there an official AbeBooks API?

Yes — AbeBooks offers **Search Web Services (SWS)**, but it is affiliate-restricted: credentials require an AbeBooks affiliate relationship. This actor is an independent alternative needing only an Apify account: $0.0015 per row, runs from the console, API or a schedule, and returns a 43-field dataset with shipping rates, condition, seller ratings and Goodreads scores.

#### What are the alternatives to this AbeBooks scraper?

For the data itself: BookScouter (ISBN buyback comparison), ThriftBooks, Biblio and Alibris are the usual **AbeBooks alternative** marketplaces — this actor reads **abebooks.com only**, so export the CSV/JSON and compare prices elsewhere yourself. On the Apify Store, comparable AbeBooks scrapers from crawlerbros, lulzasaur and automation-lab are listed above.

### SEO Keywords

abebooks scraper, abebooks api, abebooks data api, abebooks scraper apify, scrape abebooks listings, abebooks alternative, book price comparison api, used book price api, isbn price lookup, book price tracker, rare book price database, how to value rare books, book arbitrage, online book arbitrage, textbook arbitrage, resell books for profit, where to source books to resell, book sourcing for resellers, thriftbooks vs abebooks, out of print books search, abebooks international shipping, abebooks scraper python

### For AI Agents & LLM Apps

**Purpose:** scrape AbeBooks.com book listings (search, optionally detail-enriched) into a structured 43-field dataset for price comparison, arbitrage and monitoring.

Minimal working input:

```json
{ "searches": [{ "keyword": "harry potter" }] }
```

Detail-enriched variant (distinct mode):

```json
{
    "searches": [{ "isbn": "9780134093413" }],
    "enrichDetails": true,
    "maxDetailsPerSearch": 20,
    "currency": "EUR",
    "shipDest": "DE"
}
```

Output fields: `listingId`, `vendorListingId`, `title`, `author`, `authorUrl`, `isbn13`, `isbn10`, `publisher`, `publishYear`, `language`, `edition`, `binding`, `pageCount`, `description`, `condition`, `conditionLabel`, `quantity`, `bsaCodes`, `pictureUrls`, `imageUrl`, `price`, `currency`, `shippingPrice`, `shippingCurrency`, `shippingRates`, `availability`, `sellerName`, `sellerId`, `sellerCountry`, `sellerState`, `sellerCity`, `sellerStarRating`, `sellerSince`, `sellerUrl`, `goodreadsRating`, `goodreadsRatingCount`, `listingUrl`, `productUrl`, `sourceUrl`, `source`, `currencyRequested`, `shippingDestinationRequested`, `scrapedAt`.

**Behaviors an agent should know**

- Only `searches` is required (1–50 queries); every other field has a default.
- `currency` (default `USD`) and `shipDest` (default `US`) are **top-level** — not per-query fields; putting them inside a search object has no effect.
- `enrichDetails` defaults to `false`: rows are `source: "search"` and no detail pages are fetched. Set `true` to merge detail fields into the **same row** (`source: "detail"`) — this adds billed `Listing detail` events, capped per query by `maxDetailsPerSearch` (default 50).
- One row per listing either way; enrichment never creates duplicate rows, and duplicates across result pages are skipped.
- Defaults: `maxPagesPerSearch` 10 (max 50), `maxConcurrency` 40 (max 100), `maxRequestsPerCrawl` 500 across all searches, `sortBy` `bestMatch`, proxy `useApifyProxy: false`, memory 256 MB, HTTP-only.
- Free plan: 10 items per run; paid plans: unlimited.
- Billing: pay-per-event — `Result` $0.0015 per dataset row + `Listing detail` $0.0005 per fetched detail page + `Actor Start` $0.00005 per run.

### Legal & Compliance Disclaimer

This project is an independent tool, not affiliated with, endorsed by or sponsored by AbeBooks or its operators. It accesses only publicly available listing pages on abebooks.com — search results and listing/product pages — with no login, no private data and no cart or checkout interaction; it respects `robots.txt` and AbeBooks' Terms of Service, and only extracts publicly available listing data. Excessive scraping may still get your proxy IPs blocked, so keep runs proportionate. You are responsible for your own compliance with AbeBooks' terms of service and applicable data-protection law (including the GDPR where it applies) when using the data. The output contains listing and seller business information only — no personal contact data (emails or phone numbers) — and it must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `searches` (type: `array`):

Add one row per search query in the form below. Each query can combine multiple filters (keyword, author, title, ISBN, etc.).

## `maxPagesPerSearch` (type: `integer`):

Maximum number of search result pages to scrape per query (default: 10, max: 50).

## `maxDetailsPerSearch` (type: `integer`):

Maximum number of listing detail pages to visit per search for enriched data (default: 50, max: 200). Only used when detail enrichment is on.

## `enrichDetails` (type: `boolean`):

Visit each listing's detail page and merge the extra fields (description, page count, edition, ISBN-10, seller details, shipping table) into the same result row. Charged per detail page via the fixed "listing-detail" pay-per-event event. Off = search results only, fastest and cheapest.

## `maxConcurrency` (type: `integer`):

Maximum number of HTTP requests processed in parallel (default: 40, max: 100).

## `currency` (type: `string`):

Currency for prices and shipping (ISO 4217). Affects displayed prices and shipping rates.

## `shipDest` (type: `string`):

Shipping destination country (ISO 3166-1 alpha-2). Affects shipping rates shown.

## `maxRequestsPerCrawl` (type: `integer`):

Hard limit on total HTTP requests across all searches (default: 500).

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searches": [
    {
      "keyword": "harry potter"
    }
  ],
  "maxPagesPerSearch": 10,
  "maxDetailsPerSearch": 50,
  "enrichDetails": false,
  "maxConcurrency": 40,
  "currency": "USD",
  "shipDest": "US",
  "maxRequestsPerCrawl": 500,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Link to the dataset with scraped book listings.

# 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 = {
    "searches": [
        {
            "keyword": "harry potter"
        }
    ],
    "enrichDetails": false,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/abebooks-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 = {
    "searches": [{ "keyword": "harry potter" }],
    "enrichDetails": False,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/abebooks-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 '{
  "searches": [
    {
      "keyword": "harry potter"
    }
  ],
  "enrichDetails": false,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/abebooks-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/abebooks-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/zoqObPU65q3P0abX4/builds/8v1N9UvHDgr2yXxZz/openapi.json