# Google Books Scraper — Search, Catalog & ISBN Lookup (`logiover/google-books-scraper`) Actor

Scrape Google Books by keyword, author, subject, or ISBN. Extract title, authors, publisher, description, ratings, categories, pricing, and 18+ fields. No API key, no login required.

- **URL**: https://apify.com/logiover/google-books-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, Business, AI
- **Features:** Limited permissions
- **Stats:** 13 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

## Google Books Scraper — Search, Catalog & ISBN Lookup

Extract structured book data from Google Books at scale. Search by keyword, author, subject, or ISBN — no API key, no login required.

### What does Google Books Scraper do?

Google Books Scraper connects to the official Google Books Volumes API (`https://www.googleapis.com/books/v1/volumes`) to retrieve rich metadata for any book or collection of books. The actor performs keyword-driven full-text search using Google's powerful query operators (`intitle:`, `inauthor:`, `subject:`, `isbn:`) and paginates results 40 at a time using the `startIndex` parameter. It can retrieve up to 1,000 results per search query — the Google Books API pagination ceiling — and supports fetching individual volumes by their unique Google Books ID for targeted lookups. The actor is fully keyless: no API credential, no OAuth token, and no login session is required from the user. Each scraped volume yields 18 clean, structured fields per item covering bibliographic metadata, ratings, ISBNs, category taxonomy, pricing, and thumbnail URLs.

### Who is it for?

- **Publishers and editors** who need to monitor competitor catalogs, track publication trends, and analyze ratings across book categories.
- **Academic researchers and librarians** who want to bulk-collect metadata for literature reviews, citation analysis, or collection auditing.
- **E-commerce operators** building book stores or price comparison tools who need up-to-date title, ISBN, pricing, and publisher data.
- **Data scientists and ML engineers** who need large labeled datasets of books by genre, subject, or language for recommendation systems or NLP tasks.
- **Content marketers and SEO specialists** who write about books and want structured data to generate topic clusters, affiliate pages, or review content at scale.

### Use cases

- **Build a searchable book database** for a niche topic (e.g., "subject:machine learning") and export to Google Sheets for editorial planning.
- **ISBN batch lookup**: feed a list of volume IDs to get full metadata for existing catalog entries — ideal for inventory reconciliation.
- **Track ratings and reviews** for books in a category over time to identify trending or declining titles.
- **Enrich affiliate content**: pull description, thumbnail, publisher, and list price for hundreds of books in a subject area to power automated review pages.
- **Academic bibliography building**: search `inauthor:Sutton subject:reinforcement learning` to retrieve a curated metadata corpus for citation management tools.

### Why use Google Books Scraper?

- **No API key required**: The Google Books search API is public and keyless — just send a query and receive JSON. No credentials setup needed.
- **18 structured fields per book**: title, subtitle, authors, publisher, publishedDate, description, pageCount, categories, averageRating, ratingsCount, language, isbn10, isbn13, previewLink, thumbnail, saleability, listPrice — everything you need.
- **Bulk pagination**: the actor paginates across 40-item pages automatically until your `maxResults` limit or the API ceiling (1,000 results) is reached.
- **Advanced query operators**: use `intitle:`, `inauthor:`, `subject:`, `isbn:` to precision-target specific books without post-filtering.
- **Two modes in one actor**: `search` mode for broad discovery; `volumeDetail` mode for exact ID-based lookups — one actor covers all use cases.
- **Export CSV / JSON / Excel / Dataset**: results land in Apify's dataset storage and can be exported in any format, piped via webhooks, or integrated with Make/Zapier.

### What data can you extract?

The actor extracts the following fields for every book volume:

| Field | Type | Description |
|---|---|---|
| `id` | string | Google Books unique volume ID |
| `title` | string | Book title |
| `subtitle` | string | Book subtitle (if available) |
| `authors` | string | Comma-separated list of authors |
| `publisher` | string | Publisher name |
| `publishedDate` | string | Publication date (YYYY, YYYY-MM, or YYYY-MM-DD) |
| `description` | string | Full editorial description / synopsis |
| `pageCount` | string | Total number of pages |
| `categories` | string | Comma-separated BISAC categories |
| `averageRating` | string | Average reader rating (0–5) |
| `ratingsCount` | string | Total number of ratings |
| `language` | string | ISO 639-1 language code (e.g., "en", "fr") |
| `isbn10` | string | ISBN-10 identifier |
| `isbn13` | string | ISBN-13 identifier |
| `previewLink` | string | Google Books preview page URL |
| `thumbnail` | string | Book cover thumbnail image URL |
| `saleability` | string | Saleability status (FOR_SALE, NOT_FOR_SALE, FREE, etc.) |
| `listPrice` | string | List price formatted as "9.99 USD" |

#### Sample output record

```json
{
  "id": "zyTCAlFPjgYC",
  "title": "The Pragmatic Programmer",
  "subtitle": "From Journeyman to Master",
  "authors": "Andrew Hunt, David Thomas",
  "publisher": "Addison-Wesley Professional",
  "publishedDate": "1999-10-20",
  "description": "Straight from the programming trenches, The Pragmatic Programmer cuts through the increasing specialization and technicalities of modern software development to examine the core process...",
  "pageCount": "352",
  "categories": "Computers",
  "averageRating": "4.5",
  "ratingsCount": "2183",
  "language": "en",
  "isbn10": "0201616224",
  "isbn13": "9780201616224",
  "previewLink": "http://books.google.com/books?id=zyTCAlFPjgYC&printsec=frontcover",
  "thumbnail": "http://books.google.com/books/content?id=zyTCAlFPjgYC&printsec=frontcover&img=1&zoom=1",
  "saleability": "FOR_SALE",
  "listPrice": "49.99 USD"
}
```

### How to use

#### Option A — Search mode (by keyword / subject / author / ISBN)

1. Open the actor and set **Mode** to `search`.
2. Enter a **Query** using free text or operators:
   - `artificial intelligence` — broad full-text search
   - `intitle:deep learning inauthor:Goodfellow` — title + author filter
   - `subject:history isbn:9780062316097` — subject + ISBN
3. Set **Max Results** (default 200, up to 1,000).
4. Click **Run** and export results from the **Dataset** tab.

Input JSON example (search mode):

```json
{
  "mode": "search",
  "query": "artificial intelligence intitle:machine learning",
  "maxResults": 500,
  "proxy": { "useApifyProxy": true }
}
```

#### Option B — Volume detail mode (by Google Books ID)

1. Set **Mode** to `volumeDetail`.
2. In the **Volume IDs** field, provide an array of Google Books volume IDs (visible in book URLs: `books.google.com/books?id=<ID>`).
3. Run the actor — it fetches each volume individually.

Input JSON example (volumeDetail mode):

```json
{
  "mode": "volumeDetail",
  "ids": ["zyTCAlFPjgYC", "buc0AAAAMAAJ", "ITnFAAAAMAAJ"],
  "proxy": { "useApifyProxy": true }
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | Operation mode: `search` or `volumeDetail` |
| `query` | string | — | Search query; supports `intitle:`, `inauthor:`, `subject:`, `isbn:` operators. Required for search mode. |
| `ids` | array | — | List of Google Books volume IDs. Required for volumeDetail mode. |
| `maxResults` | integer | 200 | Max books to retrieve in search mode (1–5000 input; API caps at 1,000). |
| `proxy` | object | Apify proxy | Proxy configuration. Datacenter proxies work well. |

Full input JSON:

```json
{
  "mode": "search",
  "query": "subject:science fiction inauthor:Asimov",
  "maxResults": 300,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

#### Additional input fields

These optional fields are also available in the input form and API:

| Field | Type | Default | Description |
|---|---|---|---|
| `printType` | string | `"all"` | Restrict results by publication type (search mode). |
| `orderBy` | string | `"relevance"` | Order search results by relevance or by newest first. |

### Output example

```json
{
  "id": "kqsaBQAAQBAJ",
  "title": "Artificial Intelligence",
  "subtitle": "A Modern Approach",
  "authors": "Stuart Russell, Peter Norvig",
  "publisher": "Prentice Hall",
  "publishedDate": "2010",
  "description": "Artificial Intelligence: A Modern Approach, 3e offers the most comprehensive, up-to-date introduction to the theory and practice of artificial intelligence...",
  "pageCount": "1152",
  "categories": "Computers",
  "averageRating": "4",
  "ratingsCount": "459",
  "language": "en",
  "isbn10": "0136042597",
  "isbn13": "9780136042594",
  "previewLink": "http://books.google.com/books?id=kqsaBQAAQBAJ&printsec=frontcover",
  "thumbnail": "http://books.google.com/books/content?id=kqsaBQAAQBAJ&printsec=frontcover&img=1&zoom=1",
  "saleability": "FOR_SALE",
  "listPrice": "219.99 USD"
}
```

### Tips for best results

- **Use operators to narrow scope**: `intitle:python inauthor:Lutz` returns far more relevant results than a broad `python` query flooded by unrelated volumes.
- **Layer multiple operators**: Google Books supports combining `intitle:`, `inauthor:`, `subject:`, and `isbn:` in a single query for precision targeting.
- **Max 1,000 per search**: The Google Books API paginates via `startIndex` but caps at 1,000 total items per query. Run multiple searches with different keywords to cover a broader catalog.
- **Use subject: for genre/category targeting**: `subject:machine learning`, `subject:romance`, `subject:history` returns category-tagged volumes accurately.
- **ISBN search for exact lookup**: use `isbn:9780201616224` to retrieve a specific edition with guaranteed accuracy.
- **volumeDetail mode for high-accuracy enrichment**: if you already have volume IDs from a prior run, use `volumeDetail` mode for fresh, per-item metadata fetches.
- **Null fields are normal**: not every book has ratings, a price, or a thumbnail — the actor returns `null` for missing fields instead of erroring.
- **Language filtering**: add `+langRestrict=en` (future extension) or filter `language` field post-export for language-specific datasets.
- **Schedule for catalog monitoring**: run on a weekly schedule for the same query to track new publications, rating changes, and pricing updates.
- **Combine with Google Sheets integration**: pipe output directly to a Sheets webhook for live book database updates.

### Integrations

Google Books Scraper stores results in Apify's **Dataset storage**, which connects to the full Apify integration ecosystem:

- **Google Sheets**: use the Google Sheets integration to push book data live into a spreadsheet for editorial tracking.
- **Slack**: trigger a webhook notification when a scraping run completes with a summary of books found.
- **Zapier / Make**: connect dataset output to thousands of apps — CRMs, Notion databases, Airtable, email campaigns.
- **Webhooks**: configure an Apify webhook to POST run results to your own endpoint on completion.
- **Scheduler**: automate recurring searches (daily, weekly, monthly) to monitor catalog updates or price changes.
- **Apify API**: access results programmatically via the Apify REST API — perfect for CI pipelines or server-side enrichment workflows.

### API usage

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/logiover~google-books-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "query": "subject:economics",
    "maxResults": 500
  }'
```

**Node.js (Apify client):**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('logiover/google-books-scraper').call({
  mode: 'search',
  query: 'intitle:machine learning inauthor:Goodfellow',
  maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/google-books-scraper").call(run_input={
    "mode": "search",
    "query": "subject:history intitle:world war",
    "maxResults": 300,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### 🤖 AI Agents, MCP & RAG Integration

Google Books Scraper is available as an MCP tool via the Apify platform. Connect your AI agent to the Apify MCP server and invoke the actor directly from Claude, GPT-4, or any MCP-compatible LLM agent to retrieve book metadata on demand:

> "Find 100 books about behavioral economics by Nobel Prize winners and export a CSV with title, author, publisher, and average rating."

The actor returns structured JSON that AI agents can directly process, filter, and summarize without additional parsing.

Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=logiover/google-books-scraper"
    }
  }
}
```

- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.

### FAQ

#### Does this actor require an API key?

No. The Google Books Volumes API supports unauthenticated search requests. The actor makes direct HTTPS calls to `googleapis.com/books/v1/volumes` without any API key, OAuth token, or login session.

#### How many books can I get per run?

In search mode, the Google Books API allows up to 1,000 results per query (25 pages × 40 items). Set `maxResults` up to 1,000. For larger datasets, run multiple queries with different search terms and merge the results.

#### What query operators are supported?

Google Books supports: `intitle:` (search in title), `inauthor:` (search by author), `isbn:` (exact ISBN lookup), `subject:` (BISAC category), and `inpublisher:` (filter by publisher). Combine freely in a single query.

#### Why are some fields null?

Not all volumes in the Google Books database have complete metadata. Ratings, page counts, thumbnails, and pricing are often absent for older books, academic papers, or digitized public domain titles. The actor always returns all 18 fields, using `null` for any missing value.

#### Can I search by ISBN?

Yes. Use the query operator `isbn:9780201616224` (either ISBN-10 or ISBN-13) to retrieve a specific edition. Combine with other operators: `isbn:9780201616224 inauthor:Hunt` for extra precision.

#### How do I export to Excel or CSV?

After the run completes, go to the **Dataset** tab in Apify Console and click **Export** — available formats include CSV, JSON, XLSX, XML, and JSONL. You can also download via the Apify API.

#### How fast does it scrape?

The actor fetches 40 books per request with a 200 ms inter-request delay (to be respectful of the API). A run of 1,000 books takes approximately 5–8 minutes depending on proxy speed.

#### Is the data real-time?

Yes. Each run fetches live data directly from the Google Books API. Ratings, prices, and publication metadata reflect the current state in Google Books at run time.

#### Can I monitor a catalog over time?

Yes. Use Apify's **Scheduler** to run the same query weekly or monthly. Compare dataset outputs across runs to track new publications, rating changes, or price updates. Combine with webhooks to alert on changes.

#### Does it work for books in non-English languages?

Yes. Google Books indexes books in dozens of languages. Search queries in other languages (French, German, Spanish, Japanese, etc.) return results in those languages. The `language` output field shows the ISO 639-1 code.

#### What if my query returns zero results?

Zero results mean either the query is too restrictive or the term doesn't match any indexed volume. Try broadening your query — remove operators, simplify to a single keyword, and confirm the term returns results at `books.google.com/search`. The actor logs a warning but exits cleanly with no dataset items.

#### Is this related to Google Books affiliate or publisher programs?

No. This actor only reads publicly accessible search metadata from the Google Books API. It does not interact with Google Play Books purchase flows, Google Books Partner Center, or any commercial Google publishing APIs.

### 💬 Support, Issues & Reviews

- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/google-books-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/google-books-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/google-books-scraper/reviews) or bookmarking [logiover/google-books-scraper](https://apify.com/logiover/google-books-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.

### Is it legal?

Google Books Scraper accesses only the public, unauthenticated Google Books Volumes API — the same data available to any browser visitor at `books.google.com`. No login credentials, private data, or user-specific information is accessed. The actor respects the API's rate limits via request pacing and does not circumvent any access controls.

Book metadata (titles, authors, descriptions, ISBNs) is factual bibliographic information. Usage for research, catalog building, competitive analysis, and content creation is broadly accepted under fair use. Consult Google's [Terms of Service](https://developers.google.com/books/terms) and your local data regulations for commercial applications.

This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Google Books; Google Books and all other trademarks mentioned here are the property of their respective owners.

### Related scrapers

- **[Apify Amazon Books Scraper](https://apify.com/logiover)** — Extract Amazon book listings, prices, reviews, and BSR rankings.
- **[Apify Goodreads Scraper](https://apify.com/logiover)** — Scrape Goodreads book metadata, user reviews, shelves, and reading lists.
- **[Apify IMDB Scraper](https://apify.com/logiover/imdb-scraper)** — Extract IMDB data for movies, shows, actors — from the same logiover catalog.
- **[Apify B2B Lead Scraper](https://apify.com/logiover/b2b-lead-scraper)** — Find company and contact data by industry and country from OpenStreetMap.

### How much Google data can you extract in one run?

A single run returned **300 books** in 12 seconds on the example input. That example is deliberately narrow; the result limit and the input list are both yours to widen. That is roughly **1,500 books a minute**.

There is no hard ceiling built into this Actor. What bounds a run is the result limit you set, the breadth of the input you give it, and how much Google itself publishes. Because billing is per result, a wider run costs proportionally more and a narrow one costs almost nothing — so it is worth starting small and scaling once the output looks right.

### 📝 Changelog

#### 2026-11-11

- Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration.
- Added direct Issues & Reviews support links and refreshed live maintenance verification.

#### 2026-11-01

- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: independence disclaimer added; documented 2 additional input fields.

#### 2026-10-15

- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example for `maxResults` is now 333 (was 100).
- The default used when the field is left out for `maxResults` is now 5,000 (was 200).

#### 2026-09-23

- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Run reliability reviewed: 96.4% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.

#### 2026-09-01

- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.

#### 2026-08-11

- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.

***

\*Maintained: last verified 2026-11-11 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/google-books-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Operation mode: 'search' to query by keyword/author/subject/ISBN, 'volumeDetail' to fetch specific volumes by their Google Books ID.

## `query` (type: `string`):

Search query for 'search' mode. Supports operators: intitle:, inauthor:, subject:, isbn:. Example: 'artificial intelligence intitle:deep learning'. Leave empty to browse popular books (subject:fiction).

## `printType` (type: `string`):

Restrict results by publication type (search mode).

## `orderBy` (type: `string`):

Order search results by relevance or by newest first.

## `language` (type: `string`):

Restrict results to a language. Leave empty for all languages.

## `ids` (type: `array`):

List of Google Books volume IDs for 'volumeDetail' mode. Example: \["zyTCAlFPjgYC", "buc0AAAAMAAJ"]. Used only when mode=volumeDetail.

## `maxResults` (type: `integer`):

Maximum number of books to retrieve (search mode). Supports up to several thousand via pagination. Default: 200.

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

Apify proxy settings. Automatic (any group) is recommended — rotating IPs help avoid the Google Books per-IP daily quota.

## Actor input object example

```json
{
  "mode": "search",
  "query": "artificial intelligence",
  "printType": "all",
  "orderBy": "relevance",
  "language": "",
  "maxResults": 333,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "query": "python programming",
    "maxResults": 333
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/google-books-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 = {
    "query": "python programming",
    "maxResults": 333,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/google-books-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 '{
  "query": "python programming",
  "maxResults": 333
}' |
apify call logiover/google-books-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/google-books-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/uDub7ENYWMT54xBYj/builds/NqOc6XUOzeroeBTcr/openapi.json