# Academic Papers Search: Research Papers via OpenAlex & Crossref (`humble-echidna/academic-papers`) Actor Search academic and research papers in OpenAlex and Crossref (incl. arXiv preprints) by keywords, title, author, DOI, arXiv id, date range and open access. One clean record per paper: authors, venue, DOI, citation count, open-access PDF link, and the abstract where its licence allows. - **URL**: https://apify.com/humble-echidna/academic-papers.md - **Developed by:** [Michael Costa](https://apify.com/humble-echidna) (community) - **Categories:** Education, AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.70 / 1,000 papers This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### What does Academic Papers Search do? **Academic Papers Search** takes keywords, a DOI or an arXiv id and returns **research papers** as clean records: title, authors, year, venue, DOI, citation count, open-access status and free PDF link, and reusable abstracts. It searches **OpenAlex** and **Crossref** through their official public APIs, merging duplicates. [Input fields](https://apify.com/humble-echidna/academic-papers/input-schema) · [API](https://apify.com/humble-echidna/academic-papers/api) · [Use it from Claude, ChatGPT or Cursor (MCP)](#can-i-use-academic-papers-search-from-an-ai-agent-mcp) **Jump to:** [Monitor a topic](#monitor-new-papers-on-a-topic) · [Fields](#what-data-does-academic-papers-search-return) · [Price](#how-much-does-it-cost-to-search-academic-papers) · [How to use](#how-to-search-academic-papers) · [Input](#input) · [Output](#output) · [AI agents (MCP)](#can-i-use-academic-papers-search-from-an-ai-agent-mcp) · [Limits](#limits) · [FAQ](#faq) **Try it in one click:** the input comes pre-filled with the search `CRISPR base editing`. That's 20 papers (the best matches of both sources), or roughly $0.02 (20 × $0.001 per paper, plus $0.00005 for the run start). **Then replace it with what you actually want.** ### Monitor new papers on a topic Academic Papers Search can run your topic searches on a schedule and give you only the papers you haven't seen yet. Set it up once: 1. **Save a task.** Fill in **Searches, DOIs or arXiv ids**, set **Sort** to **Newest first** and turn on **Only new works** (`sort: "newest"`, `onlyNew: true` in the API). For schedules, add your own free **OpenAlex API key** (see the pricing section). Then click **Save as a new task** at the top right of the actor's page. The first run returns the top matches; later runs return only works this search hasn't returned before. 2. **Schedule it.** In Apify Console, open **Schedules**, click **Create new**, pick the task and set how often it runs (for example every Monday at 07:00, cron `0 7 * * 1`). 3. **Send the new papers where you work,** from the task's **Integrations** tab: - **Slack:** a message in the channel you choose when a run succeeds (you pick the events and can edit the message). - **Email:** *Send results email via Gmail* sends the run's results, with the dataset attached. - **Webhook:** a POST to your URL on the `ACTOR.RUN.SUCCEEDED` event. The payload's `resource.defaultDatasetId` points to the new papers: `GET https://api.apify.com/v2/datasets//items?format=json` with your API token. - **Make, Zapier or n8n:** each has an Apify step that starts on a finished run and reads its dataset. A run that finds nothing new returns 0 papers and costs only the $0.00005 start fee. Slack and email are sent for every successful run, including a quiet one; to hear only about new papers, use the webhook or Make/Zapier/n8n and skip runs whose dataset is empty. Add the **run failed** event too, so a failed run doesn't go unnoticed. Keep the task's filters fixed: the memory is per search line and filter set, so changing them starts a fresh search. ### What data does Academic Papers Search return? | Field | Example | Notes | |---|---|---| | `title` | `CRISPR-Cas9 DNA Base-Editing and Prime-Editing` | | | `authors` | `Ariel Kantor`, `Michelle E. McClements`, ... | Names only. | | `year`, `publicationDate` | `2020`, `2020-08-28` | Implausible future dates are set aside (see Output). | | `venue`, `type` | `International Journal of Molecular Sciences`, `article` | | | `doi`, `arxivId`, `pmid`, `openalexId` | `10.3390/ijms21176240` | Whichever identifiers the sources have. | | `citationCount` | `468` | | | `isOpenAccess`, `oaStatus`, `license` | `true`, `gold`, `cc-by` | `oaStatus` is gold, diamond, green, hybrid, bronze or closed. | | `pdfUrl`, `landingPageUrl` | `https://www.mdpi.com/...pdf` | The best free copy and the publisher's page. | | `abstract`, `abstractLicense` | `Many genetic diseases...`, `cc-by` | Only when the licence allows reuse; else `null`. | | `sources` | `openalex`, `crossref` | Which catalogues had the paper. | | `id` | `doi:10.3390/ijms21176240` | Stable across runs, for deduplication. | Every paper has the same fields; the full record is under [Output](#output). ### How much does it cost to search academic papers? You pay per paper returned: **$1.00 per 1,000 papers**, plus $0.00005 each time a run starts. A repeat run with nothing new costs only the start fee. **It's cheaper on paid Apify plans:** $0.90 per 1,000 papers on Starter, $0.80 on Scale and $0.70 on Business. The prices on this page are the Free-plan price, so on a paid plan you pay less than the examples show. - **The example below:** 20 papers × $0.001 = $0.02, plus the $0.00005 start fee; the repeat run $0.00005. - **A month, for example:** 10 topic searches run weekly with only-new on, about 20 new papers per search per week: 800 × $0.001 = **$0.80**, plus 4 starts. - **Caps:** **Max results per run** in the input, and **Maximum cost per run** in the run options. It stops cleanly at whichever comes first, and stops fetching as soon as the limit is covered, so a capped run is also a fast one. **OpenAlex's own daily limit.** OpenAlex counts every API call against a free daily usage budget that resets at midnight UTC ([example costs](https://help.openalex.org/access/example-costs)). Without a key the budget is $0.10 of usage a day and a search request costs $0.001, so that's **about 100 search requests a day**. Each request returns up to 100 works: a search for 20 or 100 works uses one, a search for 1,000 uses ten. DOI and arXiv lookups barely use it (a lookup by id is free). For more, [create a free OpenAlex account](https://openalex.org/settings/api) and paste your API key into **OpenAlex API key (optional)**: a free key gives 10 times the budget ($1 a day, about 1,000 search requests) at no cost to you. The field is a secret input (Apify stores it encrypted), and the key is only ever sent to OpenAlex, in a request header: never in a URL, the output or the run statistics. If the budget runs out mid-run, the run log says so, and Crossref's results are still returned. **Scheduling searches? Add your own key.** OpenAlex's documentation doesn't say how it tells keyless callers apart. If it counts them by IP address, runs on Apify's shared servers may share one keyless budget with other Apify users, so it can run out well before 100 searches. With your own free key the budget is yours alone. ### How to search academic papers 1. Open the actor and type one search per line into **Searches, DOIs or arXiv ids**: keywords, or a DOI / arXiv id to look up that paper. 2. Optionally set **Author**, **Published from / to**, **Open access only** or **Sort**. 3. Click **Start**. 4. Open the **Output** tab and export the papers as JSON, CSV or Excel, or read them through the API. 5. To follow a topic, save it as a task and schedule it (see *Monitor new papers on a topic* above). **OpenAlex** has over 300 million works, including the preprints on arXiv; **Crossref** is the DOI registry for most journals. A paper both of them know comes back once, with the best of both records. ### Example: a topic search, then a re-check The pre-filled search, with **Only new works** turned on: ```json {"queries": ["CRISPR base editing"], "maxResultsPerQuery": 20, "searchIn": "all", "sort": "relevance", "sources": ["openalex", "crossref"], "onlyNew": true} ``` The best match (real output from a local run on 2026-09-25; `authors` shortened): ```json { "id": "doi:10.1038/s41586-021-03534-y", "title": "In vivo CRISPR base editing of PCSK9 durably lowers cholesterol in primates", "authors": ["Kiran Musunuru", "Alexandra C. Chadwick", "Taiji Mizoguchi", "..."], "year": 2021, "venue": "Nature", "type": "article", "doi": "10.1038/s41586-021-03534-y", "pmid": "34012082", "abstract": null, "citationCount": 805, "isOpenAccess": false, "oaStatus": "closed", "landingPageUrl": "https://doi.org/10.1038/s41586-021-03534-y", "sources": ["openalex"] } ``` The abstract is `null` because the paper has no open licence (see the FAQ). Run again straight after, the same search returned **0 papers**, so only the start fee was charged. ### Ready-to-run examples Each example opens with the input already filled in. Run it as it is, or change the input first. - **[Find the most cited research papers on a topic](https://apify.com/humble-echidna/academic-papers/examples/most-cited-papers-on-topic)**: Search OpenAlex and Crossref for papers on any topic and get the most cited ones first, with authors, DOI, abstract, citation count and open-access links. - **[Track new research papers on a topic](https://apify.com/humble-echidna/academic-papers/examples/track-new-papers-on-topic)**: Run on a schedule and get only papers published since the last run for your research topics, newest first, with DOI, abstract and open-access links. ### Input | Field | What it does | |---|---| | **Searches, DOIs or arXiv ids** | One per line. Keywords run a search; a DOI or arXiv id (or their links) looks up that paper. | | Max works per search | At most this many works per search line, the best matches of both sources (1 to 1,000; default 20). | | Search in | Everything the source indexes (title, abstract, full text where available), or the title only. | | Author | Only works with this author in the byline. | | Published from / to | A year (`2020`), a month (`2020-06`) or a date (`2020-06-15`). | | Open access only | Only works that are free to read. | | Sort | Best match, newest first (by publication date), or most cited first. | | Sources | OpenAlex, Crossref, or both (default). | | Only new works | Skip works this search returned in an earlier run. | | OpenAlex API key (optional) | Your free OpenAlex key (secret input); raises OpenAlex's daily budget 10x. Sent to OpenAlex only. | | Max results per run | Cap the total number of works across all searches. | The filters (author, dates, open access, sort) apply to searches, not to direct DOI / arXiv lookups. ```json { "queries": ["large language models evaluation", "10.1038/nmat1849", "arXiv:1706.03762"], "maxResultsPerQuery": 50, "publishedFrom": "2023", "openAccessOnly": true, "sort": "mostCited" } ``` ### Output Every paper has the same fields. Fields the sources don't have are `null`. ```json { "id": "doi:10.3390/ijms21176240", "query": "CRISPR base editing", "title": "CRISPR-Cas9 DNA Base-Editing and Prime-Editing", "authors": ["Ariel Kantor", "Michelle E. McClements", "Robert Edward MacLaren"], "year": 2020, "publicationDate": "2020-08-28", "unreliablePublicationDate": null, "venue": "International Journal of Molecular Sciences", "type": "article", "doi": "10.3390/ijms21176240", "arxivId": null, "openalexId": "W3081580655", "pmid": "32872311", "abstract": "Many genetic diseases and undesirable traits are due to base-pair alterations ...", "abstractLicense": "cc-by", "citationCount": 468, "isOpenAccess": true, "oaStatus": "gold", "license": "cc-by", "pdfUrl": "https://www.mdpi.com/1422-0067/21/17/6240/pdf?version=1598944845", "landingPageUrl": "https://doi.org/10.3390/ijms21176240", "sources": ["openalex", "crossref"], "scrapedAt": "2026-09-24T19:40:00Z" } ``` `id` is stable across runs (`doi:...`, else `arxiv:...`, else `openalex:...`), so you can use it to deduplicate. Authors are names only. For arXiv papers (`arxivId` set), `pdfUrl` and `landingPageUrl` always point to arxiv.org (`https://arxiv.org/pdf/` and `https://arxiv.org/abs/`), whichever copy the catalogue listed first; for other papers they are the best free copy OpenAlex knows and the publisher's page. For papers only Crossref has, `isOpenAccess` is `true` when the published version has a Creative Commons licence and `null` (unknown) otherwise. **Dates too far in the future are set aside.** The sources sometimes date a work years ahead (on 2026-09-25, Crossref's newest "CRISPR base editing" works included one dated 2047 and one dated 2030). A date later than the end of next year is treated as a data error: `year` and `publicationDate` are `null` and the source's value is kept in `unreliablePublicationDate`, so the work is still returned but sorts and filters as undated. Dates up to the end of next year are kept as they are: journals date forthcoming issues ahead, and articles already online in September often carry the next year's issue date. If one source has a credible date for a work and the other an implausible one, the credible one is used. With **Newest first**, both sources are asked for nothing dated after the end of next year, so mistyped dates can't fill the top of the list, and the merged list is sorted by publication date, newest first (works without a date last). Forthcoming issues therefore come first: on 2026-09-25 the top 20 for "CRISPR base editing" were articles registered with Crossref in July to September 2026 under issue dates from February to July 2027 (many publishers register only the issue date). With the other sorts, the sources' results are interleaved by rank: OpenAlex's best match, Crossref's best match, then each one's second, and so on. ### Run it on a schedule, or from your own code - **[Schedule](https://docs.apify.com/platform/schedules):** save the input as a [task](https://docs.apify.com/platform/actors/running/tasks) and add it to a schedule, as in *Monitor new papers on a topic* above. - **[API](https://apify.com/humble-echidna/academic-papers/api):** fetch a task's latest results with `GET https://api.apify.com/v2/actor-tasks//runs/last/dataset/items?status=SUCCEEDED&format=csv` and your API token (`format` can also be `json` or `xlsx`). - **Webhooks and automation:** a [webhook](https://docs.apify.com/platform/integrations/webhooks) when a run succeeds, or Make, Zapier or n8n through [Apify's integrations](https://docs.apify.com/platform/integrations). #### Can I use Academic Papers Search from an AI agent (MCP)? Yes, through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), from Claude, ChatGPT, Cursor or any other MCP client. Add this to your client's MCP configuration (or let the agent find it with the server's actor search); your client signs you in to Apify: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=humble-echidna/academic-papers" } } } ``` To use an [Apify API token](https://console.apify.com/settings/integrations) instead of signing in, add `"headers": {"Authorization": "Bearer "}` next to `url`. The agent passes the same input JSON as above. A DOI or arXiv id looks up one paper; for searches, keep **Max works per search** small so answers stay short. ### Who it's for Researchers, research offices, R\&D and competitive-intelligence teams, and science writers who follow a topic: schedule a search with **Only new works** and get the papers you haven't seen yet, with DOI, venue, citation count and a link to a free copy where one exists. ### Why this one? - **One flat price, no usage bill.** You pay per result at the price above and nothing else: no compute, proxy or storage charges on top, apart from the $0.00005 run-start fee, so you know what a run costs before it starts. Results you don't get aren't charged. - **Two catalogues, one list, no duplicates.** Results from OpenAlex and Crossref are merged by DOI and arXiv id, within a search and across all the searches in a run. Each record says which sources had it. - **Open access done properly.** Every OpenAlex result has its open-access status (gold, diamond, green, hybrid, bronze or closed), licence, and a link to the best free copy and its PDF when there is one. - **Abstracts you can actually reuse.** An abstract is included only when the paper's licence allows reuse (CC BY, CC BY-SA, CC BY-ND, CC0, public domain); many publishers own their abstracts' copyright. - **DOI and arXiv lookups.** Paste `10.1038/nmat1849`, `https://doi.org/...`, `2010.11929` or an arxiv.org link and get that paper's record. - **Alerts.** "Only new works" + "Newest first" on a schedule gives you only the papers you haven't seen. - **Polite and safe.** It identifies itself honestly (User-Agent `HumbleEchidnaApify`), follows each site's robots.txt, and keeps to each API's published rate limit (Crossref: one request per second, one at a time). - **Reliable.** One failing search never affects the others, and if one source is down you still get the other's results. The run log and the `RUN_STATS` record say exactly what failed and why. ### Limits - **No arXiv API.** arXiv's robots.txt disallows it, so arXiv preprints come through OpenAlex (see the FAQ). - **Abstracts only under an open licence**; many papers come back without one. - **OpenAlex's free daily budget** caps keyless searches at about 100 requests a day (see the pricing section); add your own free key for more. - **Up to 1,000 works per search line.** ### FAQ #### Why isn't arXiv's API queried directly? arXiv's robots.txt disallows it: `export.arxiv.org`, the API host, has `Disallow: /` for every crawler, and `arxiv.org` disallows `/api` and `/search`. This actor follows robots.txt, so it never calls arXiv at all. arXiv preprints are still found: OpenAlex indexes arXiv, and an arXiv id is looked up through OpenAlex by the DOI arXiv registers for every paper (`10.48550/arXiv.`). Each arXiv result has its `arxivId`, with `pdfUrl` set to `https://arxiv.org/pdf/` and `landingPageUrl` to `https://arxiv.org/abs/`. Those are links built from the id, not pages this actor opens. #### Why do some papers have no abstract? Either the source has none, or the paper's licence doesn't allow reuse (for example CC BY-NC, or no open licence at all). Follow `landingPageUrl` to read it. #### Why does something that used to work now fail or return fewer results? An API may have changed its format without notice. The run log names the search and what went wrong, and every other search in the run is unaffected. Please open an issue with the input you used. #### Is it legal to search and reuse academic paper data? Yes. It only uses the owners' public, documented APIs, never a login, and it collects no personal data beyond the author names printed on each paper. - OpenAlex data is released under CC0: "the data is a public good, released under a CC0 public-domain license with no 'personal use only' carve-out and no permission to ask" ([OpenAlex pricing](https://help.openalex.org/access/pricing)). Its API allows keyless basic use and asks for no more than 100 requests per second within a daily budget ([authentication and rate limits](https://help.openalex.org/api/authentication)). Its robots.txt allows everything (`User-agent: * / Allow: /`). - Crossref: "almost none of the metadata is subject to copyright, and you may use it for any purpose. Some abstracts contained in the metadata may be subject to copyright by publishers or authors" ([Crossref REST API](https://www.crossref.org/documentation/retrieve-metadata/rest-api/)). That's why abstracts are only included under an open licence. This actor keeps to the public pool's published limits and identifies itself in its User-Agent, as Crossref's [etiquette](https://www.crossref.org/documentation/retrieve-metadata/rest-api/tips-for-using-the-crossref-rest-api/) asks. api.crossref.org has no robots.txt. - arXiv: not contacted (see above). Its papers' links are built from their ids and point to arxiv.org; other PDF links point to where OpenAlex says the paper is hosted. This actor never downloads or redistributes the PDFs. ### Related actors | Actor | Use it when | |---|---| | [PDF to Text Converter](https://apify.com/humble-echidna/document-to-text) | You want the papers' text and tables: pass it the open-access `pdfUrl` links (where the host's robots.txt allows it). | | [Dataset Transformer](https://apify.com/humble-echidna/dataset-transform) | You want to filter by year, venue or citations and export a reading list as CSV. | ### Feedback and support Found a bug, or need a field or source that isn't here? Open an issue on the **Issues** tab with the input you used. ### Versions Current version: **1.1**. See the Changelog tab for what changed in each version. # Changelog This Actor's version history is a separate document: https://apify.com/humble-echidna/academic-papers/changelog.md # Actor input Schema ## `queries` (type: `array`): One per line. Keywords run a search (e.g. CRISPR base editing). A DOI (10.1038/nmat1849 or https://doi.org/10.1038/nmat1849) or an arXiv id (2010.11929, arXiv:hep-th/9901001 or an arxiv.org/abs/ link) looks up that one work directly; the filters below don't apply to direct lookups. ## `maxResultsPerQuery` (type: `integer`): At most this many works per search line: 1 to 1,000, default 20. Each source is asked for this many best matches (in the order set by sort); works found by both are merged, and the two lists are interleaved by rank and cut to this number. ## `searchIn` (type: `string`): Where the keywords must appear. `all` (the default): everything the source indexes (title, abstract, full text where available). `title`: the title only. Doesn't apply to DOI or arXiv lookups. ## `author` (type: `string`): Only works with an author of this name in the byline, e.g. Jennifer Doudna. Leave empty for any author. ## `publishedFrom` (type: `string`): Only works published on or after this: a year (2020), a month (2020-06) or a date (2020-06-15). Leave empty (the default) for no lower limit. ## `publishedTo` (type: `string`): Only works published on or before this: a year (2024), a month (2024-12) or a date (2024-12-31). Leave empty (the default) for no upper limit. ## `openAccessOnly` (type: `boolean`): Default false. When true, only works that are free to read. OpenAlex knows the open-access status of every work; a work only Crossref found counts as open access when its published version carries a Creative Commons licence. ## `sort` (type: `string`): Which works count as the top matches for each search. `relevance` (the default): best match. `newest`: by publication date, leaving out works a source dates after the end of next year (data errors such as 2047); next year's forthcoming journal issues are kept. `mostCited`: most cited first. ## `sources` (type: `array`): Which catalogues to search: `openalex` (OpenAlex, incl. arXiv preprints) and/or `crossref` (Crossref). Default both: works found in both are merged into one result. ## `onlyNew` (type: `boolean`): Default false. When true, return only works this search hasn't returned before (remembered in your Apify account, per search line and filter set). The first run returns everything. Good for scheduled alerts; combine with sort `newest`. ## `openalexApiKey` (type: `string`): Your own free OpenAlex API key (openalex.org/settings/api). Without one, OpenAlex allows a small keyless daily budget (about 100 search requests of up to 100 works each, reset at midnight UTC); a free key gives 10x that. Only ever sent to OpenAlex, in a request header. ## `maxResults` (type: `integer`): Stop after this many works in total across all searches, e.g. 20. Minimum 1; leave empty (the default) for no limit. The run also stops cleanly at the maximum cost per run you set in the run options, whichever comes first. Set it to keep a run small and quick. ## Actor input object example ```json { "queries": [ "CRISPR base editing" ], "maxResultsPerQuery": 20, "searchIn": "all", "openAccessOnly": false, "sort": "relevance", "sources": [ "openalex", "crossref" ], "onlyNew": false } ``` # Actor output Schema ## `results` (type: `string`): No description ## `runStats` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "queries": [ "CRISPR base editing" ], "maxResultsPerQuery": 20 }; // Run the Actor and wait for it to finish const run = await client.actor("humble-echidna/academic-papers").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "queries": ["CRISPR base editing"], "maxResultsPerQuery": 20, } # Run the Actor and wait for it to finish run = client.actor("humble-echidna/academic-papers").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "queries": [ "CRISPR base editing" ], "maxResultsPerQuery": 20 }' | apify call humble-echidna/academic-papers --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,humble-echidna/academic-papers" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/TWJ8CkbtS8kb1oGwT/builds/Qade378jgZ0DfhymK/openapi.json