Huntington APIhuntington.org ↗
Search 1M+ items from The Huntington Library, Art Museum, and Botanical Gardens. Access rare books, manuscripts, paintings, plants, and more via 2 endpoints.
What is the Huntington API?
The Huntington Collections API provides access to over 1 million items across the library, museum, and botanical divisions of The Huntington Library, Art Museum, and Botanical Gardens. The search_collections endpoint returns paginated item records including name, description, division, type, identifier, and image URL. A companion get_facets endpoint exposes filterable taxonomy counts for authors, genera, families, constituents, and more.
curl -X GET 'https://api.parse.bot/scraper/5bf6c2e6-f896-43aa-ae73-5bd3b3998a4f/search_collections?page=0&type=Paintings&limit=5&query=rose&division=library&has_image=true' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace huntington-org-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Huntington Collections — search items and discover facets."""
from parse_apis.the_huntington_collections_search_api import (
Huntington, Division, ItemType, CollectionItemNotFound,
)
client = Huntington()
# Search for botanical paintings with images, capped to 5 items total.
for item in client.collectionitems.search(
query="landscape", division=Division.MUSEUM, type=ItemType.PAINTINGS, limit=5
):
print(item.name, item.identifier, item.image_url)
# Drill into a single item from a broader search.
item = client.collectionitems.search(query="William Blake", limit=1).first()
if item:
print(item.id, item.name, item.division, item.type)
# Discover what facet values are available for the botanical division.
facets = client.facetresults.get(query="rose", division=Division.BOTANICAL)
print(facets.total_hits, facets.facets)
# Typed error handling around a facet lookup.
try:
result = client.facetresults.get(query="xyznonexistent123", division=Division.LIBRARY)
print(result.total_hits)
except CollectionItemNotFound as exc:
print(f"Not found: {exc.query}")
print("exercised: collectionitems.search / facetresults.get / Division / ItemType / CollectionItemNotFound")
Search The Huntington's collections by keyword with optional filters for division, item type, and image availability. Returns paginated results with item details including name, description, division, type, identifier, and image URL. Each page returns up to `limit` items; advance `page` (0-indexed) to paginate. An empty query returns all items in the matching scope.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number (0-indexed) |
| type | string | Filter by item type (e.g., 'Paintings', 'Rare Books', 'Manuscripts', 'Plants', 'Drawings', 'Sculpture', 'Prints', 'Visual Materials', 'Decorative arts', 'Photographs') |
| limit | integer | Results per page, clamped to 1-100 |
| query | string | Search keywords (e.g., 'William Blake', 'rose', 'painting') |
| division | string | Filter by division: 'library', 'museum', or 'botanical' |
| has_image | string | Set to 'true' to only return items with images |
{
"type": "object",
"fields": {
"page": "integer, current page number",
"items": "array of CollectionItem objects with id, name, description, division, type, identifier, image_url",
"query": "string, the search query used",
"total_hits": "integer, total matching items",
"total_pages": "integer, total pages available",
"hits_per_page": "integer, results per page"
},
"sample": {
"data": {
"page": 0,
"items": [
{
"id": "lib-403805",
"name": "The rose of roses",
"type": "Rare Books",
"division": "library",
"image_url": null,
"identifier": "403805",
"description": null
},
{
"id": "lib-p16003coll12-369",
"name": "Rose Wong",
"type": "Manuscripts",
"division": "library",
"image_url": "https://rail.huntington.org/IIIF3/Image/22APN41AKRYZ",
"identifier": "mssChangpapers",
"description": "Studio portrait of Rose Wong flanked by two women."
}
],
"query": "rose",
"total_hits": 62278,
"total_pages": 12456,
"hits_per_page": 5
},
"status": "success"
}
}About the Huntington API
What the API Covers
The API surfaces collections data across three divisions: library (rare books, manuscripts, printed materials), museum (paintings, drawings, sculpture, prints), and botanical (plants indexed by genus, family, and scientific name). Each item record returned by search_collections includes an id, human-readable name, description, division, type, identifier, and an image_url where available. The endpoint is 0-indexed for pagination and accepts a limit between 1 and 100 results per page.
Filtering and Search
search_collections accepts a free-text query parameter (e.g., 'William Blake', 'rose', 'watercolor') alongside structured filters: division restricts results to library, museum, or botanical; type narrows by item category such as 'Paintings', 'Rare Books', 'Manuscripts', 'Plants', or 'Drawings'; and setting has_image to 'true' limits results to records that carry an image URL. The response includes total_hits and total_pages for accurate pagination handling.
Facets Endpoint
get_facets returns counts for each filterable dimension scoped to an optional query and division. The facets object contains keys for division, type, genus, family, family_common_name, scientific_name, author, constituent, and has_image. This is useful for building filter UIs, understanding collection composition, or discovering what authors or plant genera are represented before issuing a full search. Counts reflect only items matching the supplied query and division filters.
Coverage Notes
The botanical division includes structured botanical taxonomy fields (genus, family, scientific_name) that are absent from library and museum records. Library items carry author facets; museum items use constituent (typically artist or maker name). Not all items have images; use the has_image filter or facet to scope to records with visual assets.
The Huntington API is a managed, monitored endpoint for huntington.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when huntington.org changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official huntington.org API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a searchable front-end for rare books and manuscripts using the
queryandtypefilters insearch_collections - Aggregate botanical plant records by genus or family using the
get_facetsendpoint scoped to the botanical division - Identify all paintings or drawings by a specific artist via the
constituentfacet and a targeted keyword query - Generate image galleries of Huntington artworks by filtering
search_collectionswithhas_image=trueanddivision=museum - Compile author-level bibliographies from the library division using the
authorfacet values returned byget_facets - Analyze collection composition by division and item type using facet counts without running full paginated searches
- Cross-reference plant scientific names against external botanical databases using
scientific_namevalues from search results
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does The Huntington have an official developer API for its collections?+
What does the `get_facets` endpoint return and how is it different from `search_collections`?+
get_facets returns aggregated counts for each filterable dimension — division, type, genus, family, scientific_name, author, constituent, and has_image — without returning individual item records. It accepts an optional query and division to scope counts. Use it to discover available filter values or measure collection size before paginating through full results with search_collections.Are botanical taxonomy fields like genus and family available on all item types?+
genus, family, family_common_name, and scientific_name facets are specific to botanical division records. Library records expose author facets and museum records use constituent. Filtering get_facets or search_collections by division=botanical is required to retrieve meaningful botanical taxonomy data.Does the API return full item detail pages — transcriptions, provenance, exhibition history, or high-resolution image downloads?+
How does pagination work in `search_collections`?+
page parameter. The response includes total_hits, total_pages, and hits_per_page so you can calculate traversal. The limit parameter controls page size and is clamped to a maximum of 100. Set page=0 to start from the first result set.