Website profiles · Technology insights · Alternatives

openalex.org

OpenAlex indexes half a billion scholarly works, with their authors, institutions, sources and topics, and makes them free to search, analyze and reuse through our web app, API and bulk download.

No paid content found
Visit website
Profile views 26 Outbound visits 18 Normal
OpenAlex Full homepage screenshot

At a glance

Category
Development
Language
English
Paid-content signal
No paid content foundObserved
Registered
2018
Hosting
CloudflareInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is OpenAlex?

OpenAlex is a free, open catalog of the world's research, provided by the nonprofit OpenAlex. It indexes scholarly works along with the authors, institutions, sources, and topics connected to them, and makes that data available to search, analyze, and reuse. Access happens through a web app, an API, and bulk downloads, so you can either explore interactively or pull data programmatically.

What you can do with it

  • Search and browse research metadata in the browser-based app.
  • Query at scale through the API, useful for building dashboards, literature tools, or analytics pipelines.
  • Download bulk data when you need to run your own large-scale analysis rather than hitting an API repeatedly.

Who it suits

  • Researchers mapping a field, tracking an institution's output, or finding collaborators.
  • Developers and data scientists building scholarly search or bibliometric tools.
  • Librarians and research offices analyzing publication patterns.

A practical note The site relies on JavaScript in the browser. If you want the data without a browser, use the API; the documentation explains how, and a listing of every docs page is available. That makes the API the better entry point for automated work, while the web app fits quick, one-off exploration.

A useful next step: decide whether you need interactive lookup or repeatable, scripted access. If it's the latter, start with the API documentation rather than the web app.

How do I use the OpenAlex API to query scholarly works?

Use the OpenAlex API as a plain HTTP endpoint: you send a GET request to a URL, optionally with filter, search and paging parameters, and you get JSON back. No key or login is required for normal use.

The API host is api.openalex.org, and the works endpoint is https://api.openalex.org/works. A minimal query looks like this:

https://api.openalex.org/works?search=transformer+language+model&per-page=25

Common parameters

  • search= — free-text search across titles, abstracts and full text where available.
  • filter= — precise field matching, e.g. filter=publication_year:2020,is_oa:true. Multiple filters are comma-separated (AND); repeat the parameter or use | for OR.
  • sort= — e.g. sort=cited_by_count:desc for the most-cited works first.
  • per-page= and page= — paging; per-page is capped (check the docs for the current maximum).
  • select= — return only the fields you need, which keeps responses small.

You can also fetch a single work directly by its OpenAlex ID or DOI, e.g. https://api.openalex.org/works/https://doi.org/10.xxxx/xxxxx.

Practical tips

  • Filter first, then sort. A filtered query on publication_year or open_access.is_oa is far more useful than a broad search alone.
  • Use select=id,display_name,publication_year,cited_by_count,doi when you only need a table of results.
  • For large harvests, use cursor paging (cursor=* then follow next_cursor) rather than deep offset paging.
  • Read the field definitions before trusting a number; counts and citation figures are updated on a schedule, not in real time.

A concrete workflow

Suppose you want recent open-access papers on a topic, ranked by citations:

  1. Build the URL: https://api.openalex.org/works?filter=from_publication_date:2023-01-01,is_oa:true&search=your+topic&sort=cited_by_count:desc&per-page=50
  2. Paste it into a browser or curl to inspect the JSON.
  3. In code, loop over results, reading display_name, doi, publication_year and cited_by_count.
  4. Follow meta.next_cursor if you need more pages.

The official documentation lives at OpenAlex Help and the machine-readable index of every docs page is at help.openalex.org/llms.txt. The main site is OpenAlex.

How does OpenAlex compare to other scholarly databases like Scopus or Web of Science?

OpenAlex is best understood as an open, API-first index of scholarly works, not a direct substitute for the curated analytics suites that Scopus and Web of Science provide. It gives you free access to a very large body of metadata — works, authors, institutions, sources and topics — and lets you search, analyze and reuse that data through a web app, an API and bulk downloads. Scopus and Web of Science, by contrast, are subscription products built around selective journal coverage, citation linking and established bibliometric indicators.

The practical differences matter most in three areas:

Access and cost model. OpenAlex is free and open, with no login required for the API or bulk data. Scopus and Web of Science are licensed products; access usually comes through a university or institutional subscription, and heavy text mining or bulk export may require separate arrangements.

Coverage philosophy. OpenAlex aims to be broad and inclusive, indexing many work types and sources beyond traditional journals. Scopus and Web of Science emphasize curated, selective coverage of journals and conference proceedings, which supports their use in formal research evaluation.

Metrics and workflows. Scopus and Web of Science offer mature citation analytics, journal-level indicators and integration with evaluation exercises. OpenAlex provides citation links and topic classification, but its metrics are generally better suited to exploration, mapping and reproducible analysis than to high-stakes assessment.

When to choose which

  • Use OpenAlex when you need free, programmatic access, large-scale metadata analysis, or reproducible research on the research system itself.
  • Use Scopus or Web of Science when you need curated journal coverage, established citation indicators, or results that align with institutional evaluation criteria.
  • Use both when you want to cross-check coverage: a paper or journal may appear in one database but not another, and that difference is itself informative.

A concrete next step: if you are building a bibliometric study, prototype with the OpenAlex API or a bulk download to test your queries and coverage, then verify key findings against a subscription database you already have access to. For documentation, start at OpenAlex Help. You can also compare coverage policies directly with Scopus and Web of Science.

What data fields and metadata does OpenAlex provide for each work, author, or institution?

OpenAlex describes itself as a free and open catalog of the world's research, covering roughly half a billion scholarly works along with their authors, institutions, sources and topics. Its key strength is that the same underlying records are exposed through three routes: a web app, an API, and bulk downloads. That matters for your question because the fields available through the API and bulk data are the full record, not just what the web interface displays.

Because the site's own landing page does not enumerate individual field names, the safest way to see the exact schema is to consult its documentation rather than rely on a summary. OpenAlex points to help.openalex.org for API guidance and notes that help.openalex.org/llms.txt lists every documentation page — a useful index if you want to scan the full field list quickly.

What each entity type generally carries

Works — the core record for a paper, book chapter, dataset or similar output. Expect descriptive metadata (title, publication date, type), identifiers (including a DOI where one exists), the source it appeared in, the authors and their institutional affiliations, topic and concept classifications, and citation-related information such as references and citing works. Open-access status and links to locations are also part of the work record.

Authors — a person-level record aggregating their outputs, with name variants, associated institutions over time, and summary indicators derived from their publication and citation history.

Institutions — an organisation-level record with its name and variants, location and country, associated works and authors, and similar aggregate citation measures.

Sources — the venue or repository (journal, conference, repository), with publisher, ISSN-type identifiers, and open-access characteristics.

Topics and concepts — hierarchical subject classifications that let you group works by field rather than by keyword alone.

Practical next step

Pick one known paper, one author and one university you already understand well, then pull each through the API and inspect the returned JSON. That single exercise will show you which fields are populated, which are sparse, and how the entities link to one another — far more reliably than any field list read in the abstract.

If you are deciding between tools, the relevant trade-off is breadth versus curation: OpenAlex aims for comprehensive coverage and open reuse, so some fields will be incomplete or inferred, whereas a narrower, manually curated index may be cleaner on the records it does hold.

Can I download the entire OpenAlex dataset for bulk analysis or offline use?

Yes. OpenAlex is built to be taken in bulk, not just browsed. The site itself states that it is a free and open catalog of the world's research, and that you can get the data without a browser by using the OpenAlex API. For full offline or large-scale work, the practical route is the bulk data rather than paging through the web app or hammering the API record by record.

H3 What "bulk" gives you The catalog covers scholarly works along with their authors, institutions, sources and topics. A bulk snapshot is the right tool when your analysis needs the whole graph at once: co-authorship networks, institution-level output trends, topic mapping, deduplication experiments, or training and evaluating models over metadata. If you only need a few thousand records filtered by a query, the API is usually simpler and more current.

H3 Choosing between bulk download and API

Need Better fit
Whole-corpus counts, joins, network analysis Bulk snapshot
Reproducible offline pipeline Bulk snapshot
A filtered slice, fresh results, small volume API
Quick lookup of one work, author or institution Web app or API

H3 Practical next step Start at OpenAlex and follow its documentation for the bulk option before writing any download code. The site points to help.openalex.org for how to use the API, and notes that help.openalex.org/llms.txt lists every docs page — a fast way to find the current bulk-download and API instructions in one place.

Two things to plan for: snapshot size means you need real disk space and a loading strategy (streaming or a database rather than loading everything into memory), and a snapshot is a point-in-time copy, so decide whether you need to refresh it and how you will version successive snapshots. If your question is "can I get it all?" the answer is yes; the real decision is snapshot versus API for your specific analysis.

How can I find research on a specific topic or track citations using OpenAlex?

OpenAlex is a free catalog of scholarly works, authors, institutions, sources and topics, searchable through its web app and accessible programmatically via its API and bulk downloads. For your two goals, the web app handles quick lookups; the API is better for anything repeatable or at scale.

Finding research on a topic

  • Web app: Enter topic keywords in the search box. Results are scholarly works; use the filters (publication year, open access, work type, author, institution, source) to narrow down. The page states that OpenAlex needs JavaScript enabled in your browser for the web app to run.
  • API: Query the works endpoint with a search parameter, then add filters for year, open-access status, or topic. This suits saved queries, dashboards and scripts.
  • Bulk download: If you need the whole corpus rather than a query result, OpenAlex offers bulk data — useful for text mining or large-scale bibliometrics.

Tracking citations

  • Cited-by: Open a work's record to see the works that cite it. This is the fastest way to follow a paper's impact forward in time.
  • References: The same record shows what that work cites, so you can walk backward to its foundations.
  • API: Citation relationships are exposed as fields on work records, so you can pull citing works and filter them by year, author or institution — practical for tracking a research line rather than a single paper.
  • Author and institution views: Following an author or institution page helps you see their output and citation patterns without checking papers one by one.

Choosing between the web app and the API

Need Better fit
One-off search or browsing a paper's citations Web app
Repeated queries, alerts, or integrating into your own tools API
Large-scale analysis or text mining Bulk download
No coding Web app

Practical example

Suppose you are a graduate student reviewing "urban heat islands." Search that phrase in the web app, filter to the last five years and open-access works, then sort or filter by citation count to find influential papers. Open the most-cited one and use its cited-by list to see newer work building on it. Then use the API to export the same query as structured records for a literature matrix in a spreadsheet.

Decision criteria

  • If you only need a handful of papers and their citations, stay in the web app.
  • If you will rerun the search monthly, or need the results in your own database, use the API.
  • If you need the entire corpus, use bulk download rather than paginating through the API.

For API specifics, the site points to its help pages: OpenAlex Help — and the main catalog is at OpenAlex.

Related questions

More questions →
What Is OpenAPI-Generated API Documentation and How Does It Work?

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

  1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
  2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
  3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
  4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
  5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

Dimension OpenAPI-generated Hand-written
Source of truth The spec file The prose
Consistency with the API High, if the spec is accurate Drifts as the API changes
Effort per endpoint Low after setup Repeated for every endpoint
Narrative and tutorials Weak; needs separate pages Strong
Code samples Generated per language from schemas Written and maintained manually
Customization Bounded by the tool's templates Unlimited
Failure mode Accurate spec, poor docs, or stale spec Beautiful docs that describe an API that no longer exists

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

  • An operation list grouped by tag or path, with HTTP method and path.
  • Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
  • Request and response schemas rendered as expandable trees, including nested objects and arrays.
  • Authentication details pulled from the securitySchemes section.
  • Interactive request consoles that let a reader send a real call from the browser.
  • Generated code samples in several languages, derived from the same schemas.
  • Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

  • Your API has more than a handful of endpoints, or changes frequently.
  • You ship client SDKs or code samples in more than one language.
  • Multiple teams consume the API and need a consistent, always-current reference.
  • You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

  • Your API is small and stable, and the reference fits on one page.
  • Your documentation is mostly conceptual and contains little endpoint-level detail.
  • You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

  1. Produce one valid OpenAPI document for a single API version.
  2. Add a linter with rules for descriptions, operation IDs, and error responses.
  3. Wire the docs build into CI so a failing spec fails the build.
  4. Render the reference and review it as a reader, not as the author.
  5. Write the two or three conceptual pages the generator cannot produce.
  6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

Website Overview

An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality.

Domain and Registration

Registered in 2018, this domain has about 8 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is GoDaddy.com, LLC, a widely used domain service provider. The domain uses the common .org extension, which is not an independent safety signal.

DNS and Email

Nameservers are provided by Cloudflare, indicating managed DNS hosting. MX records point to the Google Workspace email service. No CNAME was found; the observed records resolve directly to addresses. SPF and DMARC are configured. DKIM status is unknown. TXT records include verification markers for Google. Such markers may also remain after a service stops being used.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued within the Google Trust Services cloud or CDN ecosystem. The certificate's total validity is about 90 days, consistent with a short renewal cycle.

HTTP and Browser Security

X-Powered-By exposes backend information: Express. The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. The cf-ray, via response header indicates a CDN or caching proxy in the delivery path. No obvious internal addresses or debug information were found in the headers. The Server header identifies cloudflare without an exact version.

Technology Stack Analysis

The public page identifies Cloudflare, Express without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

The meta description has 195 characters and may be shortened in search results. Twitter Card metadata is configured. The title has 56 characters, within a common display range. The observed directives allow indexing and link following. No Generator meta tag is publicly exposed.

Hosting and Email

DNSCloudflare
HostingCloudflare
EmailGoogle Workspace
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) Location unknown Inferred 104.20.26.229

Registration details

RDAP / WHOIS

RegistrarGoDaddy.com, LLC
Registered2018-03-14
Expires2028-03-14
Domain statusclient delete prohibited、client renew prohibited、client transfer prohibited、client update prohibited
Nameserversadam.ns.cloudflare.com、melinda.ns.cloudflare.com
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Aopenalex.org104.20.26.229207—
Aopenalex.org172.66.159.136207—
AAAAopenalex.org2606:4700:10::6814:1ae5300—
AAAAopenalex.org2606:4700:10::ac42:9f88300—
MXopenalex.orgaspmx.l.google.com36001
MXopenalex.orgalt1.aspmx.l.google.com36005
MXopenalex.orgalt2.aspmx.l.google.com36005
MXopenalex.orgalt3.aspmx.l.google.com360010
MXopenalex.orgalt4.aspmx.l.google.com360010
NSopenalex.orgadam.ns.cloudflare.com86400—
NSopenalex.orgmelinda.ns.cloudflare.com86400—
TXTopenalex.orggoogle-site-verification=jKpiKFDnjm5idqlvLRY6IcEQlGhKRDp2evcIjhN-nFo300—
TXTopenalex.orgv=MCPv1; k=ed25519; p=eD7D553rxLmt6R00DusrFtLfqnXZ9+fRzsMo00+zty4=300—
TXTopenalex.orgv=spf1 include:_spf.google.com include:mail.zendesk.com ~all300—
DMARC_dmarc.openalex.orgv=DMARC1; p=none300—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjectopenalex.org
IssuerGoogle Trust Services
Valid until2026-12-20T23:02 · Remaining when checked: 79 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html; charset=utf-8
cache-controlno-cache
servercloudflare

Identified technologies

CloudflareExpress

Pages, Search and Sharing

Meta descriptionOpenAlex indexes half a billion scholarly works, with their authors, institutions, sources and topics, and makes them free to search, analyze and reuse through our web app, API and bulk download.
Canonical URLhttps://openalex.org/
LanguageEnglish (default)
Twitter Cardsummary
All bots 1 allowed · 0 disallowed
  • Allow/

No sitemaps found

User reviews (0)

  • No reviews yet.