OpenAlex APIopenalex.org ↗
Search and retrieve academic works from OpenAlex's catalog of 250M+ papers. Get titles, abstracts, authors, citations, topics, and open access status.
What is the OpenAlex API?
The OpenAlex Works API exposes two endpoints — search_works and get_work — covering over 250 million academic papers, articles, books, and preprints. search_works lets you query by keyword, filter by year, type, or open-access status, and paginate through results with cursor-based navigation. get_work returns a single record with full abstract text, topic classifications, author ORCID links, institutional affiliations, and per-year citation counts.
curl -X GET 'https://api.parse.bot/scraper/937ce615-9fb8-4b29-9107-8348a1d9f1fe/search_works?sort=cited_by_count%3Adesc&query=machine+learning&cursor=*&filter=publication_year%3A2024&per_page=3' \ -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 openalex-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: OpenAlex SDK — search academic works, drill into details."""
from parse_apis.openalex_academic_works_api import OpenAlex, Sort, WorkNotFound
client = OpenAlex()
# Search for highly-cited machine learning papers, capped at 5 results.
for work in client.works.search(query="machine learning", sort=Sort.CITED_BY_COUNT_DESC, limit=5):
print(work.title, work.cited_by_count, work.is_oa)
# Drill into the first result for full details (abstract, topics, concepts).
summary = client.works.search(query="deep learning", filter="publication_year:2024", limit=1).first()
if summary:
detail = summary.details()
print(detail.title, detail.cited_by_count)
if detail.abstract:
print(detail.abstract[:120])
for topic in detail.topics[:3]:
print(topic.name, topic.score, topic.field)
# Fetch a known work directly by ID.
try:
work = client.works.get(id="https://openalex.org/W2741809807")
print(work.title, work.publication_year, work.oa_status)
for author in work.authors[:3]:
print(author.name, author.orcid)
except WorkNotFound as exc:
print(f"Work not found: {exc.work_id}")
print("exercised: works.search / WorkSummary.details / works.get")Full-text search over OpenAlex's catalog of academic works. query matches title and abstract; sort orders results by any numeric field (cited_by_count, publication_date, relevance_score) with :asc or :desc suffix. filter narrows by facets (publication_year, type, is_oa, language) combinable with commas. Paginates via opaque cursor; first page uses '*'. Each returned work carries lightweight metadata — use get_work for full abstract, topics, concepts, and references.
| Param | Type | Description |
|---|---|---|
| sort | string | Sort order. Accepted values include 'cited_by_count:desc', 'cited_by_count:asc', 'publication_date:desc', 'publication_date:asc', 'relevance_score:desc'. Omitting uses default relevance ordering. |
| query | string | Full-text search query (e.g., 'machine learning', 'CRISPR gene editing'). Omitting returns all works. |
| cursor | string | Pagination cursor. Use '*' for the first page, then use next_cursor from the response for subsequent pages. |
| filter | string | Filter expression. Examples: 'publication_year:2024', 'type:article', 'is_oa:true', 'publication_year:2020-2024'. Multiple filters can be combined with commas. |
| per_page | integer | Results per page (1-200). |
{
"type": "object",
"fields": {
"works": "array of work summary objects with id, doi, title, publication_year, publication_date, type, language, cited_by_count, relevance_score, is_oa, oa_status, oa_url, source_name, source_type, authors, abstract_inverted_index",
"per_page": "integer - results per page",
"next_cursor": "string - cursor for next page, null if no more results",
"total_count": "integer - total matching works"
}
}About the OpenAlex API
Searching and Filtering Works
The search_works endpoint accepts a query string for full-text search across titles and abstracts. Results can be narrowed with the filter parameter using expressions like publication_year:2020-2024, type:article, or is_oa:true. Multiple filters can be combined. Sorting is controlled via the sort parameter — accepted values include cited_by_count:desc, publication_date:desc, and relevance_score:desc. The endpoint returns a total_count integer alongside a works array, each work carrying fields such as doi, publication_year, language, cited_by_count, and is_oa.
Pagination
The endpoint uses cursor-based pagination. Pass cursor: '*' to start, then read next_cursor from each response and pass it as the cursor on the next call. When next_cursor is null, you have reached the end of the result set. The per_page parameter accepts values from 1 to 200, giving control over payload size per request.
Single Work Detail
The get_work endpoint takes an OpenAlex work ID (e.g., W2741809807) and returns the full detail record. Distinct from the search result shape, this record includes a reconstructed abstract string, a biblio object with volume, issue, first_page, and last_page, a topics array where each entry carries a name, score, field, and domain, and an authors array with id, name, orcid, and institutions per author. Open access delivery is indicated by is_oa and oa_url.
The OpenAlex API is a managed, monitored endpoint for openalex.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when openalex.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 openalex.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?+
- Building a literature review tool that surfaces the most-cited papers in a field using
cited_by_countandsort - Tracking open-access coverage of a research topic by filtering
search_workswithis_oa:true - Enriching an author profile page with institutional affiliations and ORCID links from
get_work'sauthorsarray - Identifying emerging research areas by querying recent publications with
publication_year:2023-2024and grouping bytopics - Feeding a citation analysis pipeline with per-work
cited_by_countand referencing the OpenAlex ID across records - Aggregating paper metadata (DOI, journal, volume, issue) for a reference manager integration using
bibliofields - Filtering academic content by language to build multilingual research discovery tools
| 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 OpenAlex have an official developer API?+
What does `get_work` return that `search_works` does not?+
get_work returns a reconstructed full abstract string, a biblio object with volume, issue, and page numbers, a topics array with domain and field classification scores, and oa_url for direct access to the open-access version. The search_works endpoint returns a summary shape optimized for list display, omitting these detail fields.Are author-level or institution-level endpoints covered?+
Can I retrieve the full reference list for a paper?+
get_work endpoint returns citation counts and topic metadata but does not expose the outbound references array. You can fork this API on Parse and revise the get_work endpoint to include the references field from the underlying OpenAlex work record.