# Book Market Intelligence (`runtime/book-market-intelligence`) Actor

Enrich book titles, ISBNs, authors, ratings, review counts, genres, covers, and source URLs across Google Books, Open Library, Goodreads URLs, and web fallbacks.

- **URL**: https://apify.com/runtime/book-market-intelligence.md
- **Developed by:** [scraping automation](https://apify.com/runtime) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Book Market Intelligence

Analyze books, authors, genres, ratings, reviews, and source evidence for publishing and market research.

### Who this is for
- Publishers and acquisition teams
- Book marketing teams
- Researchers comparing authors or categories

### What it helps you do
- Enrich book and ISBN lists with market signals
- Compare ratings, reviews, genres, and author metadata
- Prepare book datasets for dashboards or editorial research

### Inputs you can use
- Book titles, authors, ISBNs, or source URLs
- Maximum books
- Discovery settings

### Data you get
- title
- author
- ISBN
- rating
- review count
- genre
- publisher
- publication date
- source evidence

### How to get better results
- Start with a narrow, specific query or a small list of source URLs.
- Use realistic limits for the first run, then increase the volume once the output looks right.
- Keep source URLs, dates, and location context when you need repeatable market monitoring.
- Review a few sample records before connecting the dataset to a larger workflow.

### Notes
- Results depend on what the public source exposes at run time.
- Some pages may hide, delay, rename, or remove fields, so individual records can have partial data.
- Use the built-in output table to inspect results before exporting to spreadsheets, dashboards, or automation tools.

### Support
If a run returns unexpected data, open an issue from the Actor page with the input used, the run ID, and the result you expected.

# Actor input Schema

## `queries` (type: `array`):

Book titles, author/title combinations, categories, or keywords to enrich.
## `isbns` (type: `array`):

ISBN-10 or ISBN-13 values to enrich with exact-match book metadata.
## `authors` (type: `array`):

Author names to search and enrich.
## `manualBooks` (type: `array`):

Optional book records from another workflow. These are normalized and scored without live lookup.
## `includeGoogleBooks` (type: `boolean`):

Query Google Books for structured book metadata, ISBNs, categories, ratings, covers, and descriptions.
## `includeOpenLibrary` (type: `boolean`):

Query Open Library for open book metadata, ISBNs, authors, subjects, covers, and source URLs.
## `includeGoodreads` (type: `boolean`):

Use web search to find Goodreads book URLs as evidence. Goodreads is treated as an optional signal, not a required source.
## `includeWebFallbacks` (type: `boolean`):

Use DuckDuckGo HTML search to find publisher, bookseller, review, or author pages when structured sources are incomplete.
## `googleBooksApiKey` (type: `string`):

Optional Google Books API key for higher quota. Leave empty for small public API runs.
## `language` (type: `string`):

Optional two-letter language code, for example en or fr.
## `country` (type: `string`):

Optional two-letter country code used by Google Books results, for example US or FR.
## `maxResults` (type: `integer`):

Maximum enriched book records saved to the dataset.
## `maxResultsPerSource` (type: `integer`):

Maximum results requested from Google Books and Open Library per query.
## `maxWebResults` (type: `integer`):

Maximum DuckDuckGo results per fallback query when Goodreads or web fallback search is enabled.
## `minConfidenceScore` (type: `integer`):

Only save books with at least this confidence score.
## `requestTimeoutSecs` (type: `integer`):

HTTP request timeout in seconds.
## `failOnNoResults` (type: `boolean`):

Fail the run when no book intelligence records are saved.
## `proxyConfiguration` (type: `object`):

Optional Apify Proxy configuration. Structured API lookups usually work without proxy; enable proxy for Goodreads/web fallback searches if needed.

## Actor input object example

```json
{
  "queries": [
    "Dune Frank Herbert"
  ],
  "isbns": [
    "9780441172719"
  ],
  "authors": [],
  "manualBooks": [
    {
      "title": "Dune",
      "authors": [
        "Frank Herbert"
      ],
      "isbn13": "9780441172719",
      "publisher": "Ace",
      "publishedDate": "1965",
      "rating": 4.3,
      "ratingsCount": 1200000,
      "sourceUrl": "https://openlibrary.org/works/OL893415W/Dune"
    }
  ],
  "includeGoogleBooks": true,
  "includeOpenLibrary": true,
  "includeGoodreads": false,
  "includeWebFallbacks": false,
  "language": "en",
  "country": "US",
  "maxResults": 25,
  "maxResultsPerSource": 5,
  "maxWebResults": 5,
  "minConfidenceScore": 0,
  "requestTimeoutSecs": 25,
  "failOnNoResults": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

# Actor output Schema

## `books` (type: `string`):

No description

## `sources` (type: `string`):

No description

## `diagnostics` (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 = {
    "queries": [
        "Dune Frank Herbert"
    ],
    "isbns": [
        "9780441172719"
    ],
    "authors": [],
    "manualBooks": [
        {
            "title": "Dune",
            "authors": [
                "Frank Herbert"
            ],
            "isbn13": "9780441172719",
            "publisher": "Ace",
            "publishedDate": "1965",
            "rating": 4.3,
            "ratingsCount": 1200000,
            "sourceUrl": "https://openlibrary.org/works/OL893415W/Dune"
        }
    ],
    "language": "en",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("runtime/book-market-intelligence").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 = {
    "queries": ["Dune Frank Herbert"],
    "isbns": ["9780441172719"],
    "authors": [],
    "manualBooks": [{
            "title": "Dune",
            "authors": ["Frank Herbert"],
            "isbn13": "9780441172719",
            "publisher": "Ace",
            "publishedDate": "1965",
            "rating": 4.3,
            "ratingsCount": 1200000,
            "sourceUrl": "https://openlibrary.org/works/OL893415W/Dune",
        }],
    "language": "en",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("runtime/book-market-intelligence").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 '{
  "queries": [
    "Dune Frank Herbert"
  ],
  "isbns": [
    "9780441172719"
  ],
  "authors": [],
  "manualBooks": [
    {
      "title": "Dune",
      "authors": [
        "Frank Herbert"
      ],
      "isbn13": "9780441172719",
      "publisher": "Ace",
      "publishedDate": "1965",
      "rating": 4.3,
      "ratingsCount": 1200000,
      "sourceUrl": "https://openlibrary.org/works/OL893415W/Dune"
    }
  ],
  "language": "en",
  "country": "US"
}' |
apify call runtime/book-market-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=runtime/book-market-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Book Market Intelligence",
        "description": "Enrich book titles, ISBNs, authors, ratings, review counts, genres, covers, and source URLs across Google Books, Open Library, Goodreads URLs, and web fallbacks.",
        "version": "0.1",
        "x-build-id": "5b8X4ma0HOosSUSNS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/runtime~book-market-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-runtime-book-market-intelligence",
                "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/runtime~book-market-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-runtime-book-market-intelligence",
                "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/runtime~book-market-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-runtime-book-market-intelligence",
                "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",
                "properties": {
                    "queries": {
                        "title": "Book search queries",
                        "type": "array",
                        "description": "Book titles, author/title combinations, categories, or keywords to enrich.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "isbns": {
                        "title": "ISBNs",
                        "type": "array",
                        "description": "ISBN-10 or ISBN-13 values to enrich with exact-match book metadata.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "authors": {
                        "title": "Authors",
                        "type": "array",
                        "description": "Author names to search and enrich.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "manualBooks": {
                        "title": "Manual book records",
                        "type": "array",
                        "description": "Optional book records from another workflow. These are normalized and scored without live lookup."
                    },
                    "includeGoogleBooks": {
                        "title": "Use Google Books",
                        "type": "boolean",
                        "description": "Query Google Books for structured book metadata, ISBNs, categories, ratings, covers, and descriptions.",
                        "default": true
                    },
                    "includeOpenLibrary": {
                        "title": "Use Open Library",
                        "type": "boolean",
                        "description": "Query Open Library for open book metadata, ISBNs, authors, subjects, covers, and source URLs.",
                        "default": true
                    },
                    "includeGoodreads": {
                        "title": "Find Goodreads URLs",
                        "type": "boolean",
                        "description": "Use web search to find Goodreads book URLs as evidence. Goodreads is treated as an optional signal, not a required source.",
                        "default": false
                    },
                    "includeWebFallbacks": {
                        "title": "Use web fallbacks",
                        "type": "boolean",
                        "description": "Use DuckDuckGo HTML search to find publisher, bookseller, review, or author pages when structured sources are incomplete.",
                        "default": false
                    },
                    "googleBooksApiKey": {
                        "title": "Google Books API key",
                        "type": "string",
                        "description": "Optional Google Books API key for higher quota. Leave empty for small public API runs."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Optional two-letter language code, for example en or fr."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional two-letter country code used by Google Books results, for example US or FR."
                    },
                    "maxResults": {
                        "title": "Max books",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum enriched book records saved to the dataset.",
                        "default": 25
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Maximum results requested from Google Books and Open Library per query.",
                        "default": 5
                    },
                    "maxWebResults": {
                        "title": "Max web results",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum DuckDuckGo results per fallback query when Goodreads or web fallback search is enabled.",
                        "default": 5
                    },
                    "minConfidenceScore": {
                        "title": "Minimum confidence score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only save books with at least this confidence score.",
                        "default": 0
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "HTTP request timeout in seconds.",
                        "default": 25
                    },
                    "failOnNoResults": {
                        "title": "Fail if no books are saved",
                        "type": "boolean",
                        "description": "Fail the run when no book intelligence records are saved.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. Structured API lookups usually work without proxy; enable proxy for Goodreads/web fallback searches if needed.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
