OverDrive Library Title Availability Scraper

Export overdrive library title availability for known titles across public library catalogs. Supply library slugs and numeric OverDrive title IDs to collect current anonymous copy counts, holds, wait estimates, and formats where exposed. No library card, login, search, borrowing, or content downloads.

One row represents one library/title snapshot. All exposed formats are included in that row. Counts belong to the title, not to separate delivery formats.

Who is it for?

• Library collection researchers comparing digital inventory across named systems.
• Publishers and authors checking copies and hold queues for known editions.
• Data teams maintaining a recurring availability spreadsheet.
• Readers researching public catalog availability without connecting a patron account.

Why use this Actor?

Exact IDs keep a recurring panel consistent: you do not need to rerun broad searches or resolve similarly named editions every time. Duplicate IDs are removed, null values stay distinct from zero, and each row includes a collection timestamp and source link.

This is a focused lookup tool, not a catalog discovery engine. You bring the title IDs and libraries; the Actor collects the current public snapshots. It does not save historical changes or send alerts itself.

Getting started

1. Open a public library catalog, for example lapl.overdrive.com.
2. Copy its library slug (lapl).
3. From a title URL ending in /media/12715834, copy the numeric ID.
4. Enter the arrays below and run the Actor.
5. Inspect the default dataset or download JSON/CSV from Apify.

{
  "libraryIds": ["lapl"],
  "titleIds": ["12715834", "4252045"],
  "maxItems": 10
}

The first example title was owned by Los Angeles Public Library at verification; the second returned an unowned title. Catalog inventory changes independently of this Actor.

Inputs

Field	Behavior
libraryIds	Required, 1–20 public library slugs. Lowercased and trimmed; duplicates removed. No URLs or library-card IDs.
titleIds	Required, 1–200 numeric media IDs as strings, positive 32-bit integers. Trimmed and deduplicated. No ISBN, title text, URLs, or search terms.
maxItems	Global saved-row limit, default 10, range 1–1000. No zero/unlimited mode.

Every distinct library is paired with every distinct title. Libraries are processed in input order, then titles in input order. A missing title does not consume the row limit. A title that exists but is not owned can still produce a useful snapshot with isOwned: false and null numeric counts.

Unknown fields and malformed identifiers fail validation instead of being silently ignored. There are no proxy, query, keyword, account, download, or historical-date fields.

Extracted data

Fields	Meaning
libraryId, libraryName	Requested normalized slug and public display name
titleId, title, creator	Exact title ID, name, and first credited creator
mediaType	Source type, such as ebook or audiobook
isOwned, isAvailable, isHoldable	Public source flags; null if absent
ownedCopies, availableCopies	Title-level normal inventory counts, null if absent
holdsCount	Exposed title-level hold queue count
estimatedWaitDays	Source estimate in days, not a guaranteed wait
availabilityType	Source lending category when present
formats	Array of format IDs, names, and ISBNs when present
sourceUrl, scrapedAt	Public catalog link and UTC snapshot timestamp

Lucky-day inventory is not merged into normal copy counts. Formats such as Kindle, EPUB, and OverDrive Read can represent delivery options for the same title; their count is not a count of independent copies.

Output example

A representative public snapshot from the example input:

{
  "libraryId": "lapl",
  "libraryName": "Los Angeles Public Library",
  "titleId": "12715834",
  "title": "Rick Steves Snapshot Madrid & Toledo",
  "creator": "Rick Steves",
  "mediaType": "ebook",
  "isOwned": true,
  "isAvailable": true,
  "isHoldable": true,
  "ownedCopies": 2,
  "availableCopies": 2,
  "holdsCount": 0,
  "estimatedWaitDays": 7,
  "availabilityType": "normal",
  "formats": [
    { "id": "ebook-kindle", "name": "Kindle Book", "isbn": null },
    { "id": "ebook-overdrive", "name": "OverDrive Read", "isbn": "9781641717342" },
    { "id": "ebook-epub-adobe", "name": "EPUB eBook", "isbn": "9781641717342" },
    { "id": "ebook-kobo", "name": "Kobo eBook", "isbn": null }
  ],
  "sourceUrl": "https://lapl.overdrive.com/media/12715834",
  "scrapedAt": "2026-10-02T20:11:35.087Z"
}

Notice that the source can expose a wait estimate even while a title is available. The Actor preserves that estimate rather than replacing it with zero. Missing counts are null, not inferred inventory.

How much does it cost to check OverDrive library title availability?

Pay-per-event pricing uses a $0.06 start fee once per valid run plus one item event per saved library/title snapshot. Formats have no separate event charge. Unknown title IDs have no item charge; a valid run with no matching titles still incurs its start fee.

Apify tier	Price per snapshot
FREE	$0.00322
BRONZE	$0.0028
SILVER	$0.002184
GOLD	$0.00168
PLATINUM	$0.00168
DIAMOND	$0.00168

At BRONZE, 1 snapshot costs $0.0628; 10 cost $0.088; 100 cost $0.34. These examples describe Actor event prices, not a separate proxy fee. Check the live pricing panel for your applicable tier and platform terms.

Set Apify's maximum charge limit to bound spending. A billing limit can stop collection before the requested snapshot limit. A run interrupted by timeout or upstream failure can leave partial output; do not interpret it as a complete panel.

OverDrive library title availability limitations

• Public anonymous inventory is not a promise that your patron account can borrow a title.
• Consortium, advantage, visitor, restricted, and special lending rights can differ by account.
• Wait estimates are source estimates, not a queue-position calculation for your account.
• A numeric ID identifies a specific edition/media record; another edition may have another ID.
• The Actor does not search, discover new titles, borrow, reserve, log in, or download books/audio.
• It collects current snapshots only. It cannot request historical inventory.
• No guarantee is made that every library or title exposes all fields.

Reliability and troubleshooting

Requests use the public structured catalog endpoint directly, one at a time, paced at approximately two requests per second. Transient network errors, HTTP 429, and server failures receive at most three total attempts with bounded backoff. Authentication failures, challenge responses, malformed JSON, and parser mismatches fail visibly rather than producing fabricated empty data.

A title-not-found response is skipped and logged. An invalid or inactive library fails the run. A later failure can leave previously saved rows in the dataset, so inspect the terminal run status before treating the export as complete.

If a library slug fails, confirm the slug from its public OverDrive URL. If a title returns no row, confirm the numeric media ID rather than an ISBN or a reserve UUID. If counts are null, compare the public catalog: not-owned and missing inventory are different from zero available copies.

Integrations

Schedule recurring Apify runs with the same ID panel, then export each run to a spreadsheet, database, or object store. Compare snapshots downstream using libraryId plus titleId; retain scrapedAt to distinguish observations.

An Apify webhook can deliver successful-run notifications to Make, Zapier, or your application. Keep full exports outside a language model's context and perform diffing downstream. The Actor itself does not configure schedules, store historical panels, or send change alerts.

CSV exports are useful for scalar fields. JSON preserves the nested format list. Fetch only the fields your downstream workflow needs.

API usage

Use your own Apify API token via an authorization header. This starts one authorized run and waits briefly; retain the returned run ID and inspect that same run until terminal before retrieving its dataset.

curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~overdrive-libby-library-title-availability/runs?waitForFinish=30' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"libraryIds":["lapl"],"titleIds":["12715834"],"maxItems":1}'

JavaScript using the official client:

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/overdrive-libby-library-title-availability')
  .call({ libraryIds: ['lapl'], titleIds: ['12715834'], maxItems: 1 });
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
console.log(items);

Python using the official client:

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/overdrive-libby-library-title-availability').call(
    run_input={'libraryIds': ['lapl'], 'titleIds': ['12715834'], 'maxItems': 1})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items
print(items)

MCP use

Select a stable Actor-specific endpoint rather than the full Store:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/overdrive-libby-library-title-availability"

For Claude Desktop, Cursor, and VS Code with remote HTTP MCP support:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/overdrive-libby-library-title-availability",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}

Example prompt: “Check title 12715834 in lapl with maxItems 1. Show copies, holds, and the collection timestamp. Explain missing values without guessing.”

Discover actual tool names and schemas with scoped tools/list. Actor selection also adds run/data helper tools; it does not expose exactly one tool. Discovery alone is not authorization to run or abort anything.

For an authorized invocation, start once and retain the returned run ID and storage IDs. They are metadata, not rows. If the call remains nonterminal, check that same run with bounded 2/4/8-second backoff capped at 10 seconds and a total 120-second deadline. Set client request timeout above the chosen server wait plus transport margin. Recover the known run after a client timeout rather than restarting; if its ID is unknown, report uncertainty. At deadline report pending with the run ID.

After success, request untransformed dataset JSON in pages of 20 rows, explicit offsets, and selected fields. As an example consumer budget, admit at most 100 source rows and 64 KiB of serialized UTF-8 results into model context, whichever comes first. Enforce bytes host-side, including oversized rows; disclose omissions or summaries. If the client cannot intercept oversized responses, do not claim a hard byte guarantee. Track source offsets rather than transformed row counts and report the continuation offset and truncation. Full exports remain in storage. Failed-run rows are partial.

These are consumer context choices, not collection limits or promised token savings. Client-side discovery caching and prompt caching vary by client.

Legality and diagnostics

Use public catalog metadata responsibly and comply with applicable terms and law. No private circulation records or patron data are collected. This Actor is independent and is not affiliated with OverDrive or Libby. Public access does not establish a legal right to redistribute every field.

No AI inference service is used at runtime. Apify hosts your input, dataset and logs under your account's storage and retention controls; delete these in Console or through the API when no longer needed. No cross-run cache or private patron data is retained by Actor code.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

For help, open an issue on this Actor's Apify Store page with a safe input example and run link. Do not share library-card details or credentials.

FAQ

Can I search by ISBN or title? No. Provide the exact numeric media IDs from public catalog URLs.

Does zero available copies mean the library owns zero? No. Inspect ownedCopies and isOwned independently. A missing number is null and must not be converted to zero.

Are formats independently available? The source exposes title-level inventory. Formats are delivery metadata; this Actor does not assign copies to individual formats.

Why can an unowned title still return a row? The public catalog can identify titles outside a library's owned collection. The row explicitly preserves ownership and missing inventory.

Can I compare repeated runs? Yes, downstream by library/title key and timestamp. History and alerts are not built into this Actor.

Related workflows

This Actor is intentionally standalone: general book/catalog metadata products do not expose library-specific holdings. Use Apify datasets and your existing spreadsheet/database workflow for panel history rather than treating unrelated catalog records as equivalent availability evidence.