Guides
Google Books API: key setup, ISBN search, quotas, errors and the Open Library alternative
The Google Books API (https://www.googleapis.com/books/v1) searches Google’s book catalogue and returns volume records with titles, authors, ISBNs, page counts, cover links and preview status. It costs nothing to call, but every request for public data needs an API key or an OAuth token: on November 15, 2026, every keyless request we sent returned HTTP 429 with a per-day quota of 0, so the “no key needed” advice in older tutorials no longer holds. For ISBN lookups at scale, or without a Google account, Open Library’s free APIs are the main alternative, and the Python below tries Google first and falls back to Open Library.
Everything here was read from Google’s Books API documentation and Open Library’s developer pages, and checked with live requests, on November 15, 2026.
The API key requirement in November 2026
Google’s Using the API page (updated August 28, 2025) says requests for public data “must be accompanied by an identifier, which can be an API key or an access token.” The volume search examples carry &key=yourAPIKey, even though the same page notes that a search “does not require authentication”, meaning no OAuth login.
Keyless requests now fail. On November 15, 2026, a search with no key, a volumes/{id} lookup with no key and a request with no q all returned the same body, and a keyless request from a second network also got 429:
{ "error": { "code": 429, "message": "Quota exceeded for quota metric 'Queries' and limit 'Queries per day' of service 'books.googleapis.com' for consumer 'project_number:624717413613'.", "status": "RESOURCE_EXHAUSTED", "details": [ { "@type": "type.googleapis.com/google.rpc.ErrorInfo", "reason": "RATE_LIMIT_EXCEEDED", "metadata": { "quota_limit": "defaultPerDayPerProject", "quota_limit_value": "0", "quota_metric": "books.googleapis.com/default", "service": "books.googleapis.com" } } ] }}The project number in that message is not yours: it is the project Google bills keyless traffic to, and its limit is 0. A key moves your requests onto your own project’s quota. If code that worked a year ago now gets 429 on its first call, a missing key parameter is the likely cause.
Getting a Google Books API key, step by step
You create the key in the Google Cloud console with a Google account; Google’s docs list no fee for it. The steps, from Google’s Books docs and its Manage API keys page (updated November 13, 2026):
- Sign in at console.cloud.google.com and create a project, or select an existing one from the projects list.
- Open the console’s API Library, search for Books API, open it and click Enable. Google’s Getting started page says enabling an API means accepting its Terms of Service, and a key can only be restricted to an API that is already enabled.
- Go to APIs & Services > Credentials, click Create credentials and choose API key.
- Add at least one restriction, as Google’s key page now asks. Under API restrictions, choose Restrict key and select Books API. Google recommends an application restriction too: Websites (HTTP referrers) for a browser app, IP addresses for a server.
- Leave Authenticate API calls through a service account unchecked. That option makes an “authorization key” for services such as Vertex AI; the Books API needs a standard key.
- Click Create and copy the key string. Add it to every request as
key=YOUR_API_KEY.
Keep the key out of your code:
export GOOGLE_BOOKS_API_KEY=YOUR_API_KEYOn Windows PowerShell, use $env:GOOGLE_BOOKS_API_KEY = "YOUR_API_KEY". A browser app has to ship its key to the user, which is why the website restriction matters. Google’s docs say the key “is safe for embedding in URLs; it doesn’t need any encoding.”
Pricing, quotas and terms
The Books API has no published price. Google’s Books API pages list no per-call fee, and nothing in the docs asks you to enable billing for it.
Quota is per Google Cloud project, and Google publishes no default quota table for the Books API. Your limits are on the Quotas tab of the Books API page in the Cloud console. What developers report on Google’s own forum is inconsistent:
| What was reported | Where | Date |
|---|---|---|
| A developer gives the default daily quota as 1,000 requests and asks for 500,000 a day | Google Developer forum, “Requesting higher quota for Google Books API” | November 11, 2025 |
“0/1000 calls made in GCP” while a 429 said "quota_limit_value": "20000000" |
Google Developer forum, “Where to start Google Books API” | August 28, 2024 |
| A Google staff reply: eligibility for more quota “is based on your service usage history”; “If you are in your free trail, you can’t request a quota increase” | same thread | August 5, 2024 |
Keyless requests: "quota_limit_value": "0" |
Our live requests | November 15, 2026 |
The 429 body links to Google’s quota increase help. Plan for a daily cap per project, cache what you fetch, and request more from the Quotas tab before a launch, not after.
The Books API Terms of Service (last modified April 25, 2012) add three rules on top of the Google APIs Terms of Service:
- No fees without permission. “You may not charge users any fee for the use of your application, unless you have entered into a separate agreement with Google or obtained Google’s written permission.”
- Content removal. You must remove content alleged to infringe third-party rights when the law requires or Google asks, and publish contact details rights holders can use.
- User content notice. You must tell users that content they submit through the API, including names or nicknames, may be made public on Google services.
Results also depend on location. Google says it restricts results “based on your server or client application’s IP address”, so a book previewable in the United States can come back without a preview link elsewhere.
Books API v1 endpoints
All endpoints sit under https://www.googleapis.com/books/v1. The volume methods need only a key; the mylibrary methods need an OAuth token for the user.
| Method and path | What it returns | Auth |
|---|---|---|
GET /volumes?q=... |
Search results, up to 40 per page | Key |
GET /volumes/{volumeId} |
One volume | Key |
GET /users/{userId}/bookshelves |
A user’s public shelves | Key |
GET /users/{userId}/bookshelves/{shelf} |
One public shelf | Key |
GET /users/{userId}/bookshelves/{shelf}/volumes |
Volumes on a public shelf | Key |
GET /mylibrary/bookshelves |
The signed-in user’s shelves | OAuth |
GET /mylibrary/bookshelves/{shelf}/volumes |
Volumes on one of their shelves | OAuth |
POST /mylibrary/bookshelves/{shelf}/addVolume?volumeId=... |
Adds a volume; 204 No Content | OAuth |
POST /mylibrary/bookshelves/{shelf}/removeVolume?volumeId=... |
Removes a volume; 204 | OAuth |
POST /mylibrary/bookshelves/{shelf}/clearVolumes |
Empties a shelf; 204 | OAuth |
A volume ID is a string such as zyTCAlFPjgYC, the same id that appears in a books.google.com URL.
Search syntax: q operators, filters and paging
The q parameter is required on /volumes, and it matches every term, like AND. Field operators narrow it; Google calls them case-sensitive keywords:
| Operator | Matches | Example |
|---|---|---|
intitle: |
Words in the title | q=intitle:dune |
inauthor: |
Words in the author | q=flowers+inauthor:keyes |
inpublisher: |
Words in the publisher | q=inpublisher:penguin |
subject: |
A category in the volume’s category list | q=subject:fiction |
isbn: |
An ISBN-10 or ISBN-13 | q=isbn:9780143127550 |
lccn: |
A Library of Congress Control Number | q=lccn:2015295915 |
oclc: |
An OCLC number | q=oclc:28419896 |
Quote a phrase with "exact phrase" and exclude a word with -term. The other parameters on a search:
| Parameter | Values | Default |
|---|---|---|
maxResults |
0 to 40 | 10 |
startIndex |
Position of the first result, from 0 | 0 |
filter |
partial, full, free-ebooks, paid-ebooks, ebooks |
none |
printType |
all, books, magazines |
all |
orderBy |
relevance, newest |
relevance |
langRestrict |
Two-letter ISO 639-1 code, such as en |
none |
projection |
full, lite |
full |
download |
epub |
none |
fields |
A partial-response mask | all fields |
To page, raise startIndex by maxResults each call. totalItems counts all matches, which Google says “might be greater than the number of volumes returned in this response”, so stop when a page comes back without items.
fields cuts the response down to what you read, which keeps payloads small. The syntax uses / for nesting and parentheses for sub-fields:
https://www.googleapis.com/books/v1/volumes?q=isbn:9780143127550&maxResults=1&fields=totalItems,items(id,volumeInfo(title,authors,publishedDate,industryIdentifiers,imageLinks/thumbnail))&key=YOUR_API_KEYGoogle’s performance guide says an invalid mask returns 400 with a message such as “Invalid field selection a/b”. A record’s ISBNs are in volumeInfo.industryIdentifiers as ISBN_10 and ISBN_13 entries; cover URLs are in volumeInfo.imageLinks.
An ISBN search can return totalItems: 0 for a book Google holds. Try the other form (ISBN-10 for ISBN-13 or the reverse), then a title and author search, then another catalogue.
OAuth for bookshelves
Reading or changing a user’s own library needs an OAuth 2.0 access token with the scope https://www.googleapis.com/auth/books. You register an OAuth client in the same Cloud project (Credentials > Create credentials > OAuth client ID), set up the consent screen, send the user through Google’s consent flow, and pass the token as Authorization: Bearer ACCESS_TOKEN. Google’s docs say OAuth 2.0 is the only authorization protocol the API supports.
The predefined shelf IDs are the same for every user: Favorites 0, Purchased 1, To Read 2, Reading Now 3, Have Read 4, Reviewed 5, Recently Viewed 6, My eBooks 7, Books For You 8. Custom shelves have IDs above 1000. Public shelves of another user can be read with a key alone, if you know their user ID. Google’s docs say you cannot get another user’s ID through the API; they have to share it.
Google Books API errors with real response bodies
All errors share Google’s JSON error format: error.code is the HTTP status, error.status the gRPC status, and error.details[].reason the machine-readable cause. These are the bodies we recorded on November 15, 2026, trimmed:
| Status and reason | Body (error.message) |
Cause | Fix |
|---|---|---|---|
429 RESOURCE_EXHAUSTED, RATE_LIMIT_EXCEEDED, quota_limit_value: "0" |
“Quota exceeded for quota metric ‘Queries’ and limit ‘Queries per day’ of service ‘books.googleapis.com’ for consumer ‘project_number:624717413613’.” | No key and no OAuth token |
Add key=YOUR_API_KEY |
429 RESOURCE_EXHAUSTED naming your own project |
Same message with your project number | Your project’s daily or per-minute quota is used up | Cache, slow down, wait for the reset, or request more quota |
400 INVALID_ARGUMENT, API_KEY_INVALID |
“API key not valid. Please pass a valid API key.” | Mistyped, deleted or wrong-project key | Copy the key again; check the key is restricted to Books API, not another API |
401 UNAUTHENTICATED, CREDENTIALS_MISSING |
“Request is missing required authentication credential. Expected OAuth 2 access token, login cookie or other valid authentication credential.” | A mylibrary call with no token |
Send Authorization: Bearer ACCESS_TOKEN |
401 UNAUTHENTICATED, reason authError |
“Request had invalid authentication credentials.” (errors[0].message: “Invalid Credentials”) |
Expired or fake bearer token | Refresh the OAuth token |
| 400 | “Invalid field selection …” (from Google’s docs) | A bad fields mask |
Check nesting and parentheses |
200 with totalItems: 0 |
none | No match for that query in that country | Try the other ISBN form, a title search, or Open Library |
Python: ISBN lookup with Open Library fallback
This script cleans an ISBN, asks Google Books with a fields mask, and falls back to Open Library when Google returns an error or no match. It needs only requests.
import osimport time
import requests
GOOGLE_KEY = os.environ.get("GOOGLE_BOOKS_API_KEY") # set to YOUR_API_KEYGOOGLE_URL = "https://www.googleapis.com/books/v1/volumes"# Open Library asks for an app name and a contact email in the User-Agent.OL_HEADERS = {"User-Agent": "MyBookApp/1.0 (you@example.com)"}GOOGLE_FIELDS = ( "totalItems,items(id,volumeInfo(title,subtitle,authors,publisher," "publishedDate,pageCount,industryIdentifiers,imageLinks/thumbnail))")
def clean_isbn(raw): """Strip hyphens and spaces; keep a trailing X on ISBN-10.""" isbn = "".join(ch for ch in raw if ch.isdigit() or ch in "xX").upper() if len(isbn) not in (10, 13): raise ValueError(f"not an ISBN: {raw!r}") return isbn
def from_google(isbn): """Return a dict for the first Google Books match, or None.""" params = {"q": f"isbn:{isbn}", "fields": GOOGLE_FIELDS, "maxResults": 1} if GOOGLE_KEY: params["key"] = GOOGLE_KEY resp = requests.get(GOOGLE_URL, params=params, timeout=20) if resp.status_code != 200: error = resp.json().get("error", {}) raise RuntimeError(f"Google Books {resp.status_code}: {error.get('message')}") data = resp.json() if not data.get("totalItems") or "items" not in data: return None info = data["items"][0]["volumeInfo"] ids = {i["type"]: i["identifier"] for i in info.get("industryIdentifiers", [])} return { "source": "google_books", "title": info.get("title"), "authors": info.get("authors", []), "publisher": info.get("publisher"), "published": info.get("publishedDate"), "pages": info.get("pageCount"), "isbn_13": ids.get("ISBN_13"), "cover": info.get("imageLinks", {}).get("thumbnail"), }
def from_open_library(isbn): """Return a dict from Open Library's Books API, or None.""" resp = requests.get( "https://openlibrary.org/api/books", params={"bibkeys": f"ISBN:{isbn}", "format": "json", "jscmd": "data"}, headers=OL_HEADERS, timeout=20, ) resp.raise_for_status() book = resp.json().get(f"ISBN:{isbn}") if not book: return None isbn_13 = (book.get("identifiers", {}).get("isbn_13") or [None])[0] return { "source": "open_library", "title": book.get("title"), "authors": [a["name"] for a in book.get("authors", [])], "publisher": (book.get("publishers") or [{}])[0].get("name"), "published": book.get("publish_date"), "pages": book.get("number_of_pages"), "isbn_13": isbn_13 or (isbn if len(isbn) == 13 else None), "cover": f"https://covers.openlibrary.org/b/isbn/{isbn}-M.jpg?default=false", }
def lookup_isbn(raw): """Try Google Books first, then Open Library. Returns a dict or None.""" isbn = clean_isbn(raw) try: book = from_google(isbn) if book: return book except (RuntimeError, requests.RequestException) as exc: print(f"falling back to Open Library ({exc})") time.sleep(1) # stay under Open Library's 1 request a second default return from_open_library(isbn)
if __name__ == "__main__": for raw in ["978-0-14-312755-0", "0143127551"]: print(lookup_isbn(raw))We ran it on November 15, 2026 with no key and with a fake key. Google answered 429 and then 400, and both times the script fell back and printed Open Library’s record for Everything I Never Told You (Penguin Books, 2015, 297 pages). With a valid key, the Google branch returns first. The script does not check ISBN checksums; add that if users type ISBNs by hand.
Google’s generic Python client library (pip install google-api-python-client) covers the same calls:
import os
from googleapiclient.discovery import build
books = build("books", "v1", developerKey=os.environ["GOOGLE_BOOKS_API_KEY"])result = books.volumes().list(q="intitle:dune inauthor:herbert", maxResults=40, startIndex=0).execute()for item in result.get("items", []): print(item["id"], item["volumeInfo"].get("title"), item["volumeInfo"].get("publishedDate"))Open Library API: the main free alternative
Open Library, a project of the Internet Archive, offers free JSON APIs with no key. Its developer page (last edited November 8, 2026) frames them as “free, public, low-volume Web APIs” for “public-good, open, human-centered book discovery”, and points bulk users to its monthly data dumps.
Open Library rate limits and usage rules
The developer page sets two rates and asks you to identify yourself:
| Request type | Limit |
|---|---|
| Default, no identification | 1 request per second |
| With a User-Agent naming your app and a contact email or phone number | 3 requests per second |
| Covers looked up by ISBN, OCLC or LCCN (not by cover ID or OLID) | 100 requests per IP every 5 minutes, then “403 Forbidden” |
The example header on that page is User-Agent: MyLibraryApp (contact@example.org). Open Library asks you to cache responses, make requests on behalf of human users, and use search.json for batches rather than “hundreds of single-book requests”. It asks you not to scrape HTML pages, spread requests across IPs, or run it as “a backend for high-traffic commercial services”, and warns that “violations may result in aggressive rate limiting or blocking.” Its licensing page says the Internet Archive asserts no new copyright over the catalogue data. Open Library also invites you to register your application through a link on the developer page.
Open Library endpoints
| Endpoint | Use | Example |
|---|---|---|
/isbn/{isbn}.json |
One edition by ISBN-10 or ISBN-13; redirects to /books/{OLID}.json |
/isbn/9780143127550.json |
/api/books?bibkeys=ISBN:...&format=json&jscmd=data |
One or more books by ISBN, OCLC, LCCN or OLID, with author names resolved | bibkeys=ISBN:9780143127550 |
/search.json |
Search works, with q, title, author, isbn, fields, sort, lang, page, limit |
/search.json?isbn=9780143127550&fields=key,title,author_name,first_publish_year |
/works/{OLID}.json, /works/{OLID}/editions.json |
A work and its editions | /works/OL45804W.json |
/authors/{OLID}.json |
An author | /authors/OL33421A.json |
covers.openlibrary.org/b/{key}/{value}-{size}.jpg |
A cover; key is isbn, oclc, lccn, olid or id; size S, M or L |
/b/isbn/9780143127550-M.jpg |
What we saw on November 15, 2026:
/isbn/9780143127550.jsonreturned a 302 to/books/OL26389863M.json, an edition record withtitle,publishers,number_of_pages,isbn_10,coversand a link to its work, but no author names. Use/api/books?...&jscmd=data, which returned the authors by name and subjects, when you want one call per ISBN.- An ISBN Open Library does not hold returned a 404 HTML page from
/isbn/...jsonand{}from/api/books. Check for both. search.jsonwithfields=returnednumFoundanddocs; a search for The Lord of the Rings returned 473 ISBNs on its first work, because search results are works, not editions.- A cover URL returned a 302 to a file on archive.org. Without
?default=false, a missing cover is a blank image; with it, a 404.
Open Library’s books page calls /api/books a “legacy endpoint” that “may be phased out in the future” and recommends the Search API. The Python above uses it because it answers an ISBN with author names in one request; switch to search.json?isbn= if it goes.
Open Library is community-edited, so records vary. One test ISBN, 9780000000002, resolved to an unrelated 2026 record that lists 0000000000 as its ISBN-10. Check that the ISBN you sent appears in the record you get back.
Google Books and Open Library compared
| Google Books API | Open Library API | |
|---|---|---|
| Key | Required for public data (key or OAuth) | None |
| Cost | No published price | Free |
| Rate | Per-project daily quota set in the Cloud console | 1 request a second, 3 with an identifying User-Agent |
| Strengths | Descriptions, preview and e-book status, up to six cover sizes, sale info | Editions grouped under works, first publish year, subjects, LCCN and OCLC lookups, bulk dumps |
| Covers | imageLinks on the volume |
Covers API by ISBN, OLID or cover ID |
| Terms that bite | No charging users without Google’s permission; removal and notice duties | Not for bulk harvesting or high-traffic commercial backends |
| Bulk | No dump | Monthly data dumps |
MCP servers for Google Books and Open Library
We found no official MCP server from Google for Books, or from Open Library, in the registry or in either developer site. The open-source servers below are the ones in the official MCP registry or on GitHub with recent commits, as of November 15, 2026.
| Repository | Stars | Latest release or commit | Data | Key | Tools |
|---|---|---|---|---|---|
| 8enSmith/mcp-open-library | 102 | v1.2.6 on npm, October 22, 2026 | Open Library | None | search_books, get_book_by_title, get_authors_by_name, get_author_info, get_author_photo, get_book_cover, get_book_by_id |
| cyanheads/openlibrary-mcp-server | 4 | v0.4.0 on npm, October 26, 2026 | Open Library, plus search inside Internet Archive scans | None | 10 tools, including openlibrary_search_books, openlibrary_get_edition (up to 50 identifiers a call) and openlibrary_get_cover_url; also a public hosted endpoint |
| vetnet183/book-metadata-mcp | 1 | v0.2.0 on PyPI, March 1, 2026 | Google Books and Open Library | Optional GOOGLE_BOOKS_API_KEY |
find_book, search_book, get_cover, get_metadata, download_cover, bulk_search |
| juanbeniteza/mcp-google-books | 6 | Last commit October 20, 2025 | Google Books | Not documented | Book search by title, author search |
None of the four writes to Google Books or Open Library. book-metadata-mcp is the only one that covers both catalogues: it scores matches from both, and after three 429s in a row it skips Google for 60 seconds and keeps answering from Open Library. Its README says Google Books allows about 1,000 keyless requests a day; our keyless requests got a quota of 0, so set GOOGLE_BOOKS_API_KEY if you want Google results. The registry also lists hosted Google Books servers run by companies; check their terms before you send them your queries.
Claude Desktop
Open Settings > Developer > Edit Config to edit claude_desktop_config.json (~/Library/Application Support/Claude/ on macOS, %APPDATA%\Claude\ on Windows). This adds the Open Library server and the two-catalogue server:
{ "mcpServers": { "open-library": { "command": "npx", "args": ["-y", "mcp-open-library"] }, "book-metadata": { "command": "uvx", "args": ["book-metadata-mcp"], "env": { "GOOGLE_BOOKS_API_KEY": "YOUR_API_KEY" } } }}npx needs Node.js and uvx needs uv. Quit Claude Desktop completely and reopen it. cyanheads/openlibrary-mcp-server also ships a one-click .mcpb Claude Desktop extension on its releases page.
Claude Code
claude mcp add open-library -- npx -y mcp-open-libraryclaude mcp add book-metadata -e GOOGLE_BOOKS_API_KEY=YOUR_API_KEY -- uvx book-metadata-mcpclaude mcp add --transport http openlibrary-mcp-server https://openlibrary.caseyjhand.com/mcpThe last line connects to cyanheads’ hosted server, which answered an MCP initialize request on November 15, 2026 and needs no key. Add -s user to make a server available in every project.
Cursor
Put the servers in ~/.cursor/mcp.json for every project, or .cursor/mcp.json in one. Cursor can read the key from your environment:
{ "mcpServers": { "open-library": { "command": "npx", "args": ["-y", "mcp-open-library"] }, "book-metadata": { "command": "uvx", "args": ["book-metadata-mcp"], "env": { "GOOGLE_BOOKS_API_KEY": "${env:GOOGLE_BOOKS_API_KEY}" } } }}ChatGPT
ChatGPT connects only to remote MCP servers, so the local servers above cannot be added directly. OpenAI’s help page on connecting custom MCP servers says full MCP is for Business and Enterprise/Edu workspaces and that Pro users can connect servers with read and fetch permissions. A remote server such as https://openlibrary.caseyjhand.com/mcp is the kind ChatGPT can use; add it from Plugins, then the plus button, then Add custom MCP server.
Choosing a route for book data
| You need | Use | Why |
|---|---|---|
| ISBN lookups inside an app | Google Books with a key, Open Library as fallback | Google’s records and covers first; Open Library when Google has no match or hits quota |
| Lookups with no Google account or key | Open Library /api/books or search.json |
No key; send an identifying User-Agent for 3 requests a second |
| A full catalogue in your own database | Open Library data dumps | Its APIs are not for bulk harvesting, and Google offers no dump |
| Cover images on a public page | Open Library cover URLs or Google imageLinks |
Open Library asks that page src attributes point at covers.openlibrary.org |
| A user’s own Google Books shelves | Books API mylibrary with OAuth |
Only route to private shelves |
| Book lookups inside Claude or Cursor | mcp-open-library, or book-metadata-mcp with a key | No code to write |
| Selling access to an app built on Google Books | Talk to Google first | The Books API terms bar charging users without Google’s permission |
| Book facts cited in a research report | A research tool that reads book catalogues | Saves stitching catalogue calls together yourself |
Hyperresearch reads both Google Books and Open Library among its 120+ data sources, for teams that want book records cited in a report rather than raw JSON. For other public data APIs, see the Census API, FRED API in Python and SEC EDGAR API in Python guides; for more MCP servers, see MCP servers for research data and open-access full text for agents.
Sources
- Google Books APIs, Using the API (updated August 28, 2025): https://developers.google.com/books/docs/v1/using
- Google Books APIs, Getting Started: https://developers.google.com/books/docs/v1/getting_started
- Volumes: list reference: https://developers.google.com/books/docs/v1/reference/volumes/list
- Performance tips (fields parameter, updated December 23, 2025): https://developers.google.com/books/docs/v1/performance
- Libraries and Samples (updated November 9, 2026): https://developers.google.com/books/docs/v1/libraries
- Books API Terms of Service (last modified April 25, 2012): https://developers.google.com/books/terms
- Google Cloud, Getting started with Google Cloud APIs (updated November 10, 2026): https://cloud.google.com/apis/docs/getting-started
- Google Cloud, Manage API keys (updated November 13, 2026): https://cloud.google.com/docs/authentication/api-keys
- Google Cloud, request a quota increase: https://cloud.google.com/docs/quotas/help/request_increase
- Google Developer forum, Where to start Google Books API: https://discuss.google.dev/t/where-to-start-google-books-api/162388
- Google Developer forum, Requesting higher quota for Google Books API: https://discuss.google.dev/t/requesting-higher-quota-for-google-books-api-bookquest-app/286093
- Open Library Developer Center, Web API (last edited November 8, 2026): https://openlibrary.org/developers/api
- Open Library Books API: https://openlibrary.org/dev/docs/api/books
- Open Library Search API: https://openlibrary.org/dev/docs/api/search
- Open Library Covers API: https://openlibrary.org/dev/docs/api/covers
- Open Library Licensing: https://openlibrary.org/developers/licensing
- Official MCP registry: https://registry.modelcontextprotocol.io
- Claude Code MCP documentation: https://code.claude.com/docs/en/mcp
- Cursor MCP documentation: https://cursor.com/docs/context/mcp
- Connecting custom MCP servers in ChatGPT: https://help.openai.com/en/articles/12584461-connecting-custom-mcp-servers-in-chatgpt
