Using the Scopus API: Key, Token, Search

The Scopus web interface is fine for one search at a time. It stops being fine the moment the task is “get this for 400 authors” or “run this query every week” — and that is exactly the job the Scopus API is built for. This guide covers the part that actually blocks most first attempts (getting a key that returns real results, not just a 401), the two APIs people conflate, and one worked query for each.

Getting an API key

Every Scopus API call needs a developer API key. Register for one at the Elsevier Developer Portal — registration is free, and Elsevier states that free access is available to researchers at academic and non-profit institutions for non-commercial use. Once approved, the portal issues a key that goes in every request as the X-ELS-APIKey header (or, less commonly, as an apiKey query parameter).

That key alone gets you an account and a quota. It does not automatically get you full search results. That distinction is the part most people trip over.

The entitlement wall: API key vs. institutional token

Elsevier gates Scopus API responses by entitlement — the same subscription logic that governs the Scopus web interface. A bare API key, called from a network Elsevier doesn’t recognize as belonging to a subscribing institution, will authenticate fine but return a reduced or empty result set, because the API has no way to confirm you’re covered by a Scopus license.

Two ways around that:

On-campus / VPN access: if you’re calling the API from your institution’s IP range (the same range that gives you Scopus web access), Elsevier recognizes the network and applies your institution’s entitlement automatically. No extra header needed.
Institutional token (Inst Token): for scripts, servers, or remote work that aren’t on that IP range, your institution’s Scopus administrator can request an institutional token from Elsevier. You send it alongside your API key as a separate X-ELS-Insttoken header. This is what makes off-network and server-side use actually work — without it, a perfectly valid API key from home Wi-Fi will silently under-return.

If your queries are coming back thin or empty despite a working key, this is the first thing to check — not a syntax problem.

Two different APIs, two different jobs

“The Scopus API” is really a family of endpoints. The two you’ll use for almost everything are easy to conflate because both return Scopus data — but they answer different questions.

Search API — find a set of documents

The Search API takes a query string and returns a list of matching documents with core metadata: title, authors, source, publication date, DOI, and a citation count. Use it when the question is “which documents match X” — a department’s output for a year, everything citing a given topic, an author’s full publication set.

Endpoint: GET https://api.elsevier.com/content/search/scopus
Main parameter: query — the same field-code/boolean syntax covered in CASRAI’s Scopus advanced search syntax guide (this page is about the API mechanics; that one is about the query-string syntax itself)
Pagination: start (offset) and count (page size) — the result window has a system-level ceiling that varies by search cluster and account tier, enforced server-side
view parameter: STANDARD (default) or COMPLETE (more fields per result, subject to entitlement)

Abstract Retrieval API — get everything about one document

The Abstract Retrieval API takes a single document identifier and returns the full record: abstract text, author and affiliation profile links, and — with the right view — resolved reference lists. Use it when you already know which document you want and need depth on that one record, not a search across many.

It doesn’t take a query string. Instead, you identify the document in the URL path itself, using whichever identifier you have on hand:

GET https://api.elsevier.com/content/abstract/scopus_id/{scopus_id}
GET https://api.elsevier.com/content/abstract/doi/{doi}
GET https://api.elsevier.com/content/abstract/eid/{eid}
GET https://api.elsevier.com/content/abstract/pii/{pii}
GET https://api.elsevier.com/content/abstract/pubmed_id/{pubmed_id}

Its view parameter has entirely different values from the Search API’s — don’t reuse the two mentally: META and META_ABS (metadata, with or without the abstract), FULL (everything you’re entitled to), REF (paginated reference lists, using its own startref/refcount parameters), and ENTITLED (just tells you what you’re allowed to see, useful for checking access before requesting the rest).

Worked example: from a search to a full record

A realistic two-step workflow — find candidate documents, then pull full detail on the ones that matter:

Step 1 — search for the documents:

GET https://api.elsevier.com/content/search/scopus?query=TITLE-ABS-KEY(research+data+management)+AND+PUBYEAR+%3E+2023&count=25&view=STANDARD
Headers:
  X-ELS-APIKey: your-api-key
  X-ELS-Insttoken: your-institutional-token   (omit if calling from a recognized campus network)
  Accept: application/json

This returns up to 25 documents whose title, abstract, or keywords contain “research data management,” published after 2023 — each with a dc:identifier field carrying its Scopus ID.

Step 2 — pull the full record for one result:

GET https://api.elsevier.com/content/abstract/scopus_id/85123456789?view=FULL
Headers:
  X-ELS-APIKey: your-api-key
  X-ELS-Insttoken: your-institutional-token
  Accept: application/json

(Replace 85123456789 with the real Scopus ID from Step 1’s results.) The FULL view returns the abstract text, author/affiliation links, and — if you add the REF view in a separate call — the resolved reference list for that document.

Response format and rate limits

Set Accept: application/json unless you specifically want XML or RDF/XML — JSON is the simplest to parse and what most example code in Elsevier’s own documentation uses. Every response carries quota-tracking headers reporting your remaining calls for that key; check your account dashboard on the Developer Portal for your specific weekly/daily limits, since these are tied to your access tier and Elsevier can revise them, rather than a single number safe to quote here as fixed.

Where the API earns its keep over the web interface

Three cases where scripting against the API is the right call instead of exporting from the Scopus website by hand:

Recurring publication lists — a department or research office that needs “everyone’s output this quarter” as a standing, re-runnable job rather than a one-time manual export.
Cross-referencing at scale — checking hundreds of DOIs against Scopus coverage, or pulling reference lists across a corpus for a citation-network analysis, where clicking through the interface one record at a time isn’t practical.
Feeding another system — a CRIS, an institutional repository, or a custom dashboard that needs Scopus metadata as structured JSON rather than a downloaded spreadsheet.

For anything smaller than that — a single literature search, checking one author’s h-index — the ordinary Scopus web interface or the advanced search syntax it supports is simpler and doesn’t require managing keys and tokens at all.

Frequently asked questions

Do I need an institutional token to use the Scopus API at all?

No — an API key alone is enough to authenticate and get some response. But without either an institutional token or a recognized on-campus network connection, Elsevier can’t confirm you’re covered by a Scopus subscription, so results are typically reduced rather than the full entitled set. For anything beyond quick testing, get the institutional token from your library or research-office Scopus administrator.

Is the Scopus API free to use?

Registration for an API key is free, and Elsevier states free access is available to academic/non-profit researchers for non-commercial use — but the actual data you can retrieve is still gated by your institution’s Scopus subscription entitlement. The key removes the technical barrier, not the licensing one.

What’s the difference between the Search API and the Abstract Retrieval API in one sentence?

Search API answers “which documents match this query” and returns a list; Abstract Retrieval API answers “tell me everything about this one document” and takes an identifier, not a query string.

Can I get full text through the Scopus API?

Not through Scopus itself — Scopus is an abstract-and-citation database, not a full-text repository, so its API returns abstracts, metadata, and reference lists, not article full text. Elsevier’s separate ScienceDirect APIs handle full text for Elsevier-published content specifically.

How is this different from the Scopus advanced search syntax guide?

That guide covers the query-string language itself — field codes like TITLE-ABS-KEY, proximity operators, boolean precedence — the same syntax whether you’re typing it into the Scopus website or passing it as the query parameter here. This guide covers getting authenticated and calling the API programmatically. See Scopus Advanced Search Syntax for the query language in depth.

Related CASRAI pages

Scopus — what the database is and how it’s curated
Scopus Advanced Search Syntax — field codes, proximity operators, and precedence rules for the query string this API’s Search endpoint accepts
Using the OpenAlex API — a free, no-key alternative covering similar ground for open bibliographic data
Using the PubMed E-utilities API — the equivalent programmatic-access guide for PubMed
Metadata Search Engines for Scholarly Research — where Scopus sits among CORE, BASE, and other discovery tools
Scopus vs. Web of Science vs. OpenAlex — how Scopus’s coverage compares to its main alternatives

Using the Scopus API: API Key, Institutional Token, and Search vs. Abstract Retrieval

Ask about Using the Scopus API: API Key, Institutional Token, and Search vs. Abstract Retrieval