> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to OpenAlex

The OpenAlex connector lets your AI agent act in each user's OpenAlex account. Each user connects their own OpenAlex access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 31 tools.

**Authentication:** Bearer Token
**Categories:** Search, Analytics
**Tools:** 31: 31 read, 0 write, 0 destructive
**Users sign in with:** Access token
**Built by:** Scalekit connector
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=OPENALEX)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the OpenAlex connection

   In **AgentKit > Connections**, create an OpenAlex connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'openalex'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize OpenAlex:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'openalex_get_rate_limit',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "openalex"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize OpenAlex:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="openalex_get_rate_limit",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their OpenAlex credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'openalex_autocomplete',
  toolInput: {
    entity_type: 'works',
    q: '<q>',
  },
  connector: 'openalex',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="openalex_autocomplete",
    tool_input={
        "entity_type": "works",
        "q": "<q>",
    },
    connection_name="openalex",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `openalex_autocomplete`

Autocomplete · Read-only

Suggest OpenAlex entities of one type whose names match a partial string, for type-ahead look-ups.
Returns up to 10 matches with id, display_name, hint (authors for a work, institution for an author, host for a source, location for an institution), external_id (DOI, ORCID, ROR, ISSN), entity_type, works_count and cited_by_count.
Use openalex_autocomplete to turn a name or partial title into an ID quickly, or to match an ID such as an ORCID or DOI. Use the openalex_search_* tools for full ranked results with paging.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `entity_type` (`string`, required): Which entity type to suggest: works, authors, sources, institutions, topics, publishers, funders or keywords. Example: institutions. One of: `works`, `authors`, `sources`, `institutions`, `topics`, `publishers`, `funders`, `keywords`.
- `q` (`string`, required): The partial name, title or ID to complete. External IDs such as an ORCID URL, DOI or OpenAlex ID are matched directly. Example: flori.
- `filter` (`string`, optional): Optional OpenAlex filter string applied before suggesting. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Example: country_code:us.
- `search` (`string`, optional): Optional full-text search applied before suggesting, to narrow the candidates. Example: medical.

Example input: `{"entity_type":"works","q":"<q>"}`

### `openalex_get_author`

Get Author · Read-only

Fetch one OpenAlex author by ID.
Returns the full author record: id, orcid, display_name and name variants, works_count, cited_by_count, summary stats (h-index, i10-index), last known institutions, affiliations and top topics. Single-record lookups are free.
Use openalex_get_author when you have the ID. Use openalex_search_authors to find a author by name or text, and openalex_list_authors to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The author to fetch: an OpenAlex author ID (A5023888391) or an ORCID as a URL (https://orcid.org/0000-0001-6187-6610). Example: A5023888391.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,orcid,display_name,works_count,cited_by_count.

Example input: `{"id":"<id>"}`

### `openalex_get_funder`

Get Funder · Read-only

Fetch one OpenAlex funder by ID.
Returns the full funder record: id, display_name, alternate titles, description, country code, ROR and other IDs, awards_count, works_count, cited_by_count and summary stats. Single-record lookups are free.
Use openalex_get_funder when you have the ID. Use openalex_search_funders to find a funder by name or text, and openalex_list_funders to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The OpenAlex funder ID to fetch. Example: F4320332161.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,country_code,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_institution`

Get Institution · Read-only

Fetch one OpenAlex institution by ID.
Returns the full institution record: id, ror, display_name, type, country code and geo location, parent and child institutions, works_count, cited_by_count and summary stats. Single-record lookups are free.
Use openalex_get_institution when you have the ID. Use openalex_search_institutions to find a institution by name or text, and openalex_list_institutions to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The institution to fetch: an OpenAlex institution ID (I136199984) or a ROR ID as a URL (https://ror.org/03vek6s52). Example: I136199984.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,ror,display_name,country_code,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_keyword`

Get Keyword · Read-only

Fetch one OpenAlex keyword by ID.
Returns the full keyword record: id, display_name, works_count and cited_by_count. Single-record lookups are free.
Use openalex_get_keyword when you have the ID. Use openalex_search_keywords to find a keyword by name or text, and openalex_list_keywords to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The keyword to fetch: its OpenAlex keyword ID, which is a lowercase hyphenated slug (the last part of https://openalex.org/keywords/machine-learning). Example: machine-learning.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_publisher`

Get Publisher · Read-only

Fetch one OpenAlex publisher by ID.
Returns the full publisher record: id, display_name, alternate titles, hierarchy level and parent publisher, country codes, works_count, cited_by_count and summary stats. Single-record lookups are free.
Use openalex_get_publisher when you have the ID. Use openalex_search_publishers to find a publisher by name or text, and openalex_list_publishers to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The OpenAlex publisher ID to fetch. Example: P4310320595.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,hierarchy_level,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_rate_limit`

Get Rate Limit · Read-only

Check the connected OpenAlex API key's daily budget and how much of it is left.
Returns the key's daily limit, usage so far today, remaining budget and time until the reset at midnight UTC. Free.
Use openalex_get_rate_limit before a large batch of list or search calls, or after a 429 error.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `openalex_get_source`

Get Source · Read-only

Fetch one OpenAlex source by ID.
Returns the full source record: id, issn_l and issn list, display_name, type, host organization (publisher), is_oa, is_in_doaj, APC prices, works_count, cited_by_count and summary stats. Single-record lookups are free.
Use openalex_get_source when you have the ID. Use openalex_search_sources to find a source by name or text, and openalex_list_sources to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The source to fetch: an OpenAlex source ID (S137773608) or an ISSN with the issn: prefix (issn:0028-0836). Example: S137773608.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,issn_l,display_name,type,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_topic`

Get Topic · Read-only

Fetch one OpenAlex topic by ID.
Returns the full topic record: id, display_name, description, keywords, subfield, field and domain, works_count, cited_by_count and sibling topics. Single-record lookups are free.
Use openalex_get_topic when you have the ID. Use openalex_search_topics to find a topic by name or text, and openalex_list_topics to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The OpenAlex topic ID to fetch. Example: T11636.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,description,works_count.

Example input: `{"id":"<id>"}`

### `openalex_get_work`

Get Work · Read-only

Fetch one OpenAlex work by ID.
Returns the full work record: id, doi, title, publication year and date, type, authorships with institutions, primary location and source, open access status, topics, keywords, cited_by_count and referenced_works. Single-record lookups are free.
Use openalex_get_work when you have the ID. Use openalex_search_works to find a work by name or text, and openalex_list_works to filter many.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `id` (`string`, required): The work to fetch: an OpenAlex work ID (W2741809807), a DOI as a URL (https://doi.org/10.7717/peerj.4375) or with the doi: prefix (doi:10.7717/peerj.4375), or a PubMed ID with the pmid: prefix (pmid:29456894). Example: W2741809807.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,cited_by_count.

Example input: `{"id":"<id>"}`

### `openalex_group_entities`

Group Entities · Read-only

Count OpenAlex entities of one type grouped by the values of a field, after an optional filter or search.
Returns meta.count (total matching entities), meta.groups_count (groups on this page) and group_by, a list of key, key_display_name and count, at most 200 groups per page. Costs the same as the underlying list ($0.0001) or search ($0.001).
Use openalex_group_entities for breakdowns such as works per year, per type, per institution or per open access status. Use the openalex_list_* tools for the records themselves.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `entity_type` (`string`, required): Which entity type to count: works, authors, sources, institutions, topics, publishers, funders or keywords. Example: works. One of: `works`, `authors`, `sources`, `institutions`, `topics`, `publishers`, `funders`, `keywords`.
- `group_by` (`string`, required): The field to group by. Add :include_unknown to also count entities with no value (string and ID fields key it as unknown, numeric fields as -111). Common values for works: publication_year, type, open_access.oa_status, primary_location.source.id, authorships.institutions.id, authorships.countries, topics.id. Example: publication_year.
- `cursor` (`string`, optional): Cursor for paging through more than 200 groups: send * first, then meta.next_cursor from each response until it is null. When paging, groups are sorted by key, not by count. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the entities before grouping. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Example: authorships.institutions.id:I136199984,publication_year:2015-2024.
- `per_page` (`integer`, optional): Number of groups per page, from 1 to 200. Example: 200.
- `search` (`string`, optional): Optional text search applied before grouping. Example: machine learning.

Example input: `{"entity_type":"works","group_by":"<group_by>"}`

### `openalex_list_authors`

List Authors · Read-only

List OpenAlex disambiguated author profiles, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, orcid, display_name and name variants, works_count, cited_by_count, summary stats (h-index, i10-index), last known institutions, affiliations and top topics. Costs $0.0001 per call.
Use openalex_list_authors for structured filters such as IDs, years or counts. Use openalex_search_authors for a text query, openalex_get_author for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the authors returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: last_known_institutions.id, last_known_institutions.country_code, affiliations.institution.id, topics.id, has_orcid, orcid, works_count, cited_by_count, summary_stats.h_index. Example: last_known_institutions.id:I136199984,works_count:>100.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,orcid,display_name,works_count,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, works_count, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{}`

### `openalex_list_citing_works`

List Citing Works · Read-only

List the works that cite a given OpenAlex work, with optional extra filters.
Returns meta.count (the number of citing works) and results with id, doi, title, year, type, authorships, source and cited_by_count. Costs $0.0001 per call.
Use openalex_list_citing_works to follow citations forward in time. Use openalex_list_work_references for the works a paper cites.
Requires an OpenAlex work ID (W...); resolve a DOI with openalex_get_work first.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `work_id` (`string`, required): OpenAlex ID of the cited work. Returns the works whose reference lists include it. Use the W ID, not a DOI. Example: W2741809807.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): Extra OpenAlex filter conditions, ANDed with the citation link. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Example: publication_year:2020-2024,is_oa:true.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, publication_date, publication_year, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{"work_id":"<work_id>"}`

### `openalex_list_funders`

List Funders · Read-only

List OpenAlex research funders: agencies, foundations and other organizations that fund research, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, display_name, alternate titles, description, country code, ROR and other IDs, awards_count, works_count, cited_by_count and summary stats. Costs $0.0001 per call.
Use openalex_list_funders for structured filters such as IDs, years or counts. Use openalex_search_funders for a text query, openalex_get_funder for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the funders returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_code, continent, is_global_south, works_count, cited_by_count. Example: country_code:us,works_count:>1000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,country_code,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_institutions`

List Institutions · Read-only

List OpenAlex research institutions: universities, companies, hospitals, government bodies and nonprofits, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, ror, display_name, type, country code and geo location, parent and child institutions, works_count, cited_by_count and summary stats. Costs $0.0001 per call.
Use openalex_list_institutions for structured filters such as IDs, years or counts. Use openalex_search_institutions for a text query, openalex_get_institution for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the institutions returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_code, continent, type, ror, is_global_south, works_count, cited_by_count, lineage. Example: country_code:us,type:education.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,ror,display_name,country_code,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_keywords`

List Keywords · Read-only

List OpenAlex keywords: short topic-derived phrases that OpenAlex tags works with, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, display_name, works_count and cited_by_count. Costs $0.0001 per call.
Use openalex_list_keywords for structured filters such as IDs, years or counts. Use openalex_search_keywords for a text query, openalex_get_keyword for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the keywords returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: works_count, cited_by_count. Example: works_count:>1000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_publishers`

List Publishers · Read-only

List OpenAlex publishing organizations, arranged in parent and child hierarchies, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, display_name, alternate titles, hierarchy level and parent publisher, country codes, works_count, cited_by_count and summary stats. Costs $0.0001 per call.
Use openalex_list_publishers for structured filters such as IDs, years or counts. Use openalex_search_publishers for a text query, openalex_get_publisher for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the publishers returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_codes, hierarchy_level, parent_publisher, works_count, cited_by_count. Example: country_codes:gb,hierarchy_level:0.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,hierarchy_level,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_sources`

List Sources · Read-only

List OpenAlex sources that host works: journals, conference proceedings, repositories and ebook platforms, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, issn_l and issn list, display_name, type, host organization (publisher), is_oa, is_in_doaj, APC prices, works_count, cited_by_count and summary stats. Costs $0.0001 per call.
Use openalex_list_sources for structured filters such as IDs, years or counts. Use openalex_search_sources for a text query, openalex_get_source for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the sources returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: type, is_oa, is_in_doaj, issn, host_organization, country_code, works_count, cited_by_count, summary_stats.h_index. Example: type:journal,is_oa:true.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,issn_l,display_name,type,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_topics`

List Topics · Read-only

List OpenAlex research topics (about 4,500), each placed in a subfield, field and domain, narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, display_name, description, keywords, subfield, field and domain, works_count, cited_by_count and sibling topics. Costs $0.0001 per call.
Use openalex_list_topics for structured filters such as IDs, years or counts. Use openalex_search_topics for a text query, openalex_get_topic for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the topics returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: domain.id, field.id, subfield.id, works_count, cited_by_count. Example: field.id:17,works_count:>10000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,description,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{}`

### `openalex_list_work_references`

List Work References · Read-only

List the works that a given OpenAlex work cites (its reference list), with optional extra filters.
Returns meta.count (the number of referenced works OpenAlex matched) and results with id, doi, title, year, type, authorships, source and cited_by_count. Costs $0.0001 per call.
Use openalex_list_work_references to follow citations backward. Use openalex_list_citing_works for later works that cite this one.
Requires an OpenAlex work ID (W...); resolve a DOI with openalex_get_work first.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `work_id` (`string`, required): OpenAlex ID of the citing work. Returns the works in its reference list. Use the W ID, not a DOI. Example: W2741809807.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): Extra OpenAlex filter conditions, ANDed with the citation link. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Example: publication_year:2020-2024,is_oa:true.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, publication_date, publication_year, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{"work_id":"<work_id>"}`

### `openalex_list_works`

List Works · Read-only

List OpenAlex scholarly works (articles, books, datasets, preprints, dissertations and more), narrowed by an optional filter string and sorted as you choose.
Returns meta.count (total matches), meta.next_cursor when cursor paging, and results with id, doi, title, publication year and date, type, authorships with institutions, primary location and source, open access status, topics, keywords, cited_by_count and referenced_works. Costs $0.0001 per call.
Use openalex_list_works for structured filters such as IDs, years or counts. Use openalex_search_works for a text query, openalex_get_work for one record by ID, and openalex_group_entities for counts per value.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `corpus` (`string`, optional): Which works corpus to query: core (the default curated catalog, about 324 million works), expansion (about 193 million extra works only), or all (both). One of: `core`, `expansion`, `all`.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the works returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: publication_year, from_publication_date, to_publication_date, type, is_oa, authorships.author.id, authorships.institutions.id, primary_location.source.id, topics.id, keywords.id, funders.id, cited_by_count, cites, cited_by, doi, has_fulltext. Example: publication_year:2024,is_oa:true,type:article.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, publication_date, publication_year, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{}`

### `openalex_sample_entities`

Sample Random Entities · Read-only

Return a random sample of OpenAlex entities of one type, optionally from a filtered set and reproducible with a seed.
Returns meta.count and randomly chosen records of the requested type, paged with per_page and page. Costs $0.0001 per call.
Use openalex_sample_entities for random records or unbiased samples. Use the openalex_list_* tools for ordered results.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `entity_type` (`string`, required): Which entity type to sample: works, authors, sources, institutions, topics, publishers, funders or keywords. Example: works. One of: `works`, `authors`, `sources`, `institutions`, `topics`, `publishers`, `funders`, `keywords`.
- `sample` (`integer`, required): Size of the random sample, from 1 to 10,000. Set per_page as well to get more than 25 in one call. Example: 50.
- `filter` (`string`, optional): OpenAlex filter string that limits the set to sample from. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Example: publication_year:2023,type:article.
- `page` (`integer`, optional): Page of the sample to return, starting at 1. Use with seed so pages come from the same sample. Example: 1.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `seed` (`integer`, optional): Seed for a reproducible sample: the same seed and filter return the same records. Required when paging through a sample. Example: 42.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name.

Example input: `{"entity_type":"works","sample":50}`

### `openalex_search_authors`

Search Authors · Read-only

Search OpenAlex authors by text in their display name and alternative names, with optional filters.
Returns meta.count and authors ranked by relevance_score: id, orcid, display_name and name variants, works_count, cited_by_count, summary stats (h-index, i10-index), last known institutions, affiliations and top topics. Costs $0.001 per call.
Use openalex_search_authors to find authors by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_authors for filters only, and openalex_get_author once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in author display name and alternative names. Matching is stemmed, ignores stop words and matches whole words. Example: Heather Piwowar.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the authors returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: last_known_institutions.id, last_known_institutions.country_code, affiliations.institution.id, topics.id, has_orcid, orcid, works_count, cited_by_count, summary_stats.h_index. Example: last_known_institutions.id:I136199984,works_count:>100.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,orcid,display_name,works_count,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, works_count, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_funders`

Search Funders · Read-only

Search OpenAlex funders by text in their display name, alternate titles and description, with optional filters.
Returns meta.count and funders ranked by relevance_score: id, display_name, alternate titles, description, country code, ROR and other IDs, awards_count, works_count, cited_by_count and summary stats. Costs $0.001 per call.
Use openalex_search_funders to find funders by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_funders for filters only, and openalex_get_funder once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in funder display name, alternate titles and description. Matching is stemmed, ignores stop words and matches whole words. Example: National Science Foundation.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the funders returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_code, continent, is_global_south, works_count, cited_by_count. Example: country_code:us,works_count:>1000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,country_code,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_institutions`

Search Institutions · Read-only

Search OpenAlex institutions by text in their display name, alternative names and acronyms, with optional filters.
Returns meta.count and institutions ranked by relevance_score: id, ror, display_name, type, country code and geo location, parent and child institutions, works_count, cited_by_count and summary stats. Costs $0.001 per call.
Use openalex_search_institutions to find institutions by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_institutions for filters only, and openalex_get_institution once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in institution display name, alternative names and acronyms. Matching is stemmed, ignores stop words and matches whole words. Example: Stanford.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the institutions returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_code, continent, type, ror, is_global_south, works_count, cited_by_count, lineage. Example: country_code:us,type:education.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,ror,display_name,country_code,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_keywords`

Search Keywords · Read-only

Search OpenAlex keywords by text in their display name and description, with optional filters.
Returns meta.count and keywords ranked by relevance_score: id, display_name, works_count and cited_by_count. Costs $0.001 per call.
Use openalex_search_keywords to find keywords by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_keywords for filters only, and openalex_get_keyword once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in keyword display name and description. Matching is stemmed, ignores stop words and matches whole words. Example: machine learning.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the keywords returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: works_count, cited_by_count. Example: works_count:>1000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_publishers`

Search Publishers · Read-only

Search OpenAlex publishers by text in their display name and alternate titles, with optional filters.
Returns meta.count and publishers ranked by relevance_score: id, display_name, alternate titles, hierarchy level and parent publisher, country codes, works_count, cited_by_count and summary stats. Costs $0.001 per call.
Use openalex_search_publishers to find publishers by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_publishers for filters only, and openalex_get_publisher once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in publisher display name and alternate titles. Matching is stemmed, ignores stop words and matches whole words. Example: Elsevier.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the publishers returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: country_codes, hierarchy_level, parent_publisher, works_count, cited_by_count. Example: country_codes:gb,hierarchy_level:0.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,hierarchy_level,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_sources`

Search Sources · Read-only

Search OpenAlex sources by text in their display name, alternate titles and abbreviated title, with optional filters.
Returns meta.count and sources ranked by relevance_score: id, issn_l and issn list, display_name, type, host organization (publisher), is_oa, is_in_doaj, APC prices, works_count, cited_by_count and summary stats. Costs $0.001 per call.
Use openalex_search_sources to find sources by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_sources for filters only, and openalex_get_source once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in source display name, alternate titles and abbreviated title. Matching is stemmed, ignores stop words and matches whole words. Example: Nature.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the sources returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: type, is_oa, is_in_doaj, issn, host_organization, country_code, works_count, cited_by_count, summary_stats.h_index. Example: type:journal,is_oa:true.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,issn_l,display_name,type,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_topics`

Search Topics · Read-only

Search OpenAlex topics by text in their display name and description, with optional filters.
Returns meta.count and topics ranked by relevance_score: id, display_name, description, keywords, subfield, field and domain, works_count, cited_by_count and sibling topics. Costs $0.001 per call.
Use openalex_search_topics to find topics by name or text and get their IDs. Use openalex_autocomplete for fast type-ahead suggestions, openalex_list_topics for filters only, and openalex_get_topic once you have an ID.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `search` (`string`, required): Text to search in topic display name and description. Matching is stemmed, ignores stop words and matches whole words. Example: machine learning.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the topics returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: domain.id, field.id, subfield.id, works_count, cited_by_count. Example: field.id:17,works_count:>10000.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,display_name,description,works_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include works_count, cited_by_count, display_name and relevance_score (searches only). Example: works_count:desc.

Example input: `{"search":"climate change"}`

### `openalex_search_works`

Search Works · Read-only

Search OpenAlex works by text in titles, abstracts, full text and keywords, with optional filters.
Returns meta.count and works ranked by relevance_score (text match plus a capped citation boost): id, doi, title, year, type, authorships, source, open access status and cited_by_count. Costs $0.001 per call.
Use openalex_search_works for keyword and Boolean queries. Use openalex_semantic_search_works to match by meaning or a long passage, openalex_list_works for filters only, and openalex_autocomplete for quick title look-ups.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `corpus` (`string`, optional): Which works corpus to query: core (the default curated catalog, about 324 million works), expansion (about 193 million extra works only), or all (both). One of: `core`, `expansion`, `all`.
- `cursor` (`string`, optional): Cursor for deep paging past 10,000 results. Send * on the first call, then pass meta.next_cursor from each response until it is null. Do not combine with page. Example: *.
- `filter` (`string`, optional): OpenAlex filter string that narrows the works returned. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. Common attributes: publication_year, from_publication_date, to_publication_date, type, is_oa, authorships.author.id, authorships.institutions.id, primary_location.source.id, topics.id, keywords.id, funders.id, cited_by_count, cites, cited_by, doi, has_fulltext. Example: publication_year:2024,is_oa:true,type:article.
- `page` (`integer`, optional): Page number for basic paging, starting at 1. page times per_page cannot exceed 10,000; use cursor to go deeper. Do not combine with cursor. Example: 2.
- `per_page` (`integer`, optional): Number of results per page, from 1 to 100. OpenAlex's default is 25. Example: 25.
- `rerank` (`boolean`, optional): Set to true to reorder the top 100 results by how well each answers the search, using a decision model. Adds $0.001 to the call. Works only with a relevance-sorted search: leave sort empty.
- `search` (`string`, optional): Text to search across work titles, abstracts, full text and keywords (stemmed). Supports AND, OR and NOT in uppercase, double-quoted phrases, "phrase"~N proximity and term~N fuzzy matching. Unquoted words are ANDed. Set at least one of search, search_title_abstract_keywords, search_title, search_title_and_abstract or search_exact; scoped searches combine with AND. Do not combine with search_exact (OpenAlex returns 400). Example: "climate change" AND adaptation.
- `search_exact` (`string`, optional): Unstemmed search across titles, abstracts and full text. Required for wildcards: * matches any characters and ? one character, with at least 3 characters before the wildcard. Use instead of search, not with it: sending both returns 400. Example: machin*.
- `search_title` (`string`, optional): Text to search in work titles only. Combined with other search inputs using AND. Example: CRISPR.
- `search_title_abstract_keywords` (`string`, optional): Text to search in titles, abstracts and keywords only, ignoring full text. This is what openalex.org searches by default. Combined with other search inputs using AND. Example: antimicrobial resistance.
- `search_title_and_abstract` (`string`, optional): Text to search in titles and abstracts only, without keyword matching. Combined with other search inputs using AND. Example: graph neural networks.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,cited_by_count.
- `sort` (`string`, optional): Sort order: a field name, with :desc for descending (ascending is the default). Separate several sort keys with commas. Sortable fields include cited_by_count, publication_date, publication_year, display_name and relevance_score (searches only). Example: cited_by_count:desc.

Example input: `{}`

### `openalex_semantic_search_works`

Semantic Search Works · Read-only

Find OpenAlex works whose meaning is closest to a query, using AI embeddings of titles and abstracts.
Returns up to 50 works ordered by similarity, each with relevance_score, id, doi, title, year, type, authorships, source and cited_by_count.
Use openalex_semantic_search_works for a description, abstract or research question worded differently from the papers. Use openalex_search_works for exact keywords, Boolean logic or paging past 50 results.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `query` (`string`, required): The text to match by meaning: a question, a paragraph, an abstract or a grant aim. Up to 2,000 characters are used. Example: predicting drug toxicity from molecular structure.
- `filter` (`string`, optional): OpenAlex filter string that narrows the works matched. Join attribute:value pairs with commas (AND). Use | between values for OR within one attribute (up to 100 values), ! before a value to negate it, > or < for numbers, and a dash for ranges (publication_year:2020-2024). Filter by OpenAlex IDs, not names: resolve a name to an ID with openalex_autocomplete or a search tool first. The cited_by_count and country_code filters are not supported with semantic search. Example: publication_year:>2020,is_oa:true.
- `per_page` (`integer`, optional): Number of works to return, from 1 to 50. Semantic search returns at most 50 results. Example: 25.
- `select` (`string`, optional): Comma-separated list of root-level fields to return instead of the full record. Nested fields such as open_access.is_oa are not allowed; select open_access instead. Example: id,doi,display_name,publication_year,relevance_score.

Example input: `{"query":"<query>"}`

## Related

Other Search connectors ([all 51](/agentkit/connectors/?category=search)):

- [Supadata](/agentkit/connectors/supadata/): Scalekit connector, API key, 21 tools
- [Exa](/agentkit/connectors/exa/): Scalekit connector, API key, 21 tools
- [Brave Search](/agentkit/connectors/brave/): Scalekit connector, API key, 18 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |