# Research Papers Search for RAG, from OpenAlex data (`br_data_hub/openalex-research-search`) Actor Search 250M+ scholarly papers from OpenAlex data, or look up DOIs: authors with institutions, venue, citations, topics, open PDF link, rebuilt abstract, APA and BibTeX, and a Markdown card for RAG. - **URL**: https://apify.com/br_data_hub/openalex-research-search.md - **Developed by:** [br_data_hub](https://apify.com/br_data_hub) (community) - **Categories:** AI, Education, Developer tools - **Security:** Limited permissions - **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 ## Research Papers Search for RAG, from OpenAlex data > Independent tool. Not affiliated with, endorsed by or sponsored by OpenAlex or OurResearch; it uses their open (CC0) data through the public API. Search **250M+ scholarly works** in [OpenAlex](https://openalex.org), the open catalog of research papers, or look up a list of **DOIs**, and get clean, citation-ready records built for **RAG pipelines and research agents**: - title, authors **with institutions** (name, country, ROR) and ORCID, venue, year, DOI, citation count, FWCI, topics and keywords - the **abstract as plain text**, rebuilt from OpenAlex's `abstract_inverted_index` (the API does not return abstracts as text) - the best **open-access PDF link** and license - ready-made citations in **APA 7** and **BibTeX** - a self-contained **`markdown` card per paper** (title, authors, venue, DOI, citations, abstract, APA), ready to embed in a vector database or paste into an LLM prompt - **deduplication by DOI** (OpenAlex sometimes holds two records for one paper) and **cursor paging**, so large searches (up to 100,000 papers) are read 200 at a time without the 10,000-result cap of basic paging ### Input | Field | Description | |---|---| | `query` | Words to find in titles, abstracts and full text. Supports `AND`, `OR`, `NOT` and `"exact phrases"`. | | `dois` | Optional list of DOIs (`10.xxxx/...` or `https://doi.org/...`). Lookup mode: the query and filters are ignored, duplicates are removed, unknown DOIs come back with `status: "not_found"` and are free. | | `yearFrom` / `yearTo` | Publication year range. | | `openAccessOnly` | Only papers free to read somewhere (default `true`). | | `types` | Work types: article, preprint, review, book, book-chapter, dissertation, dataset, report... | | `fields` | Research areas: OpenAlex's 26 fields (Computer Science, Medicine, Social Sciences...). | | `topics` | OpenAlex topic ids (`T10028`) or names; names are matched to the closest topic and shown in the log. | | `minCitations` | Only papers cited at least this many times. | | `language` | ISO 639-1 code (`en`, `pt`, `es`...). | | `hasAbstract` | Skip papers without an abstract (useful for RAG). | | `includeRetracted` | Retracted papers are excluded unless this is on. | | `sort` | `relevance` (needs a query), `citations`, `newest` or `oldest`. | | `maxResults` | Stop after this many papers (default 25, up to 100,000). | | `includeMarkdown` | Add the `markdown` card (default `true`). | | `contactEmail` | Optional e-mail sent to OpenAlex as `mailto` (their "polite pool"). Not stored in results. | | `openalexApiKey` | Optional OpenAlex API key for higher daily limits. | The default input searches open-access papers on "retrieval augmented generation" since 2023 and returns 25 papers in a few seconds. ### Output One dataset item per paper (views: *Overview*, *Citations*, *Markdown for RAG*): ```json { "status": "ok", "openalexId": "W2741809807", "doi": "10.7717/peerj.4375", "doiUrl": "https://doi.org/10.7717/peerj.4375", "title": "The state of OA: a large-scale analysis of the prevalence and impact of Open Access articles", "publicationYear": 2018, "type": "article", "authors": [ {"name": "Juan Pablo Alperin", "orcid": "https://orcid.org/0000-0002-9344-7439", "position": "middle", "institutions": [{"name": "Simon Fraser University", "countryCode": "CA", "ror": "https://ror.org/0213rcc28", "type": "education"}]} ], "venue": "PeerJ", "volume": "6", "firstPage": "e4375", "citedByCount": 1000, "isOpenAccess": true, "oaStatus": "gold", "pdfUrl": "https://peerj.com/articles/4375.pdf", "license": "cc-by", "topics": [{"name": "scientometrics and bibliometrics research", "field": "Decision Sciences", "domain": "Social Sciences"}], "abstract": "Despite growing interest in Open Access (OA) to scholarly literature, there is an unmet need for ...", "citationApa": "Piwowar, H., Priem, J., Larivière, V., Alperin, J. P., & Haustein, S. (2018). The state of OA: ... PeerJ, 6, e4375. https://doi.org/10.7717/peerj.4375", "citationBibtex": "@article{piwowar2018state,\n title = {The state of OA: ...},\n author = {Piwowar, Heather and ...},\n journal = {PeerJ},\n year = {2018}, ...\n}", "markdown": "# The state of OA: ...\n\n- **Authors:** Heather Piwowar, Jason Priem, ...\n- **DOI:** https://doi.org/10.7717/peerj.4375\n...\n\n## Abstract\n\nDespite growing interest ...\n\n## Citation (APA)\n\n..." } ``` (Example values are shortened.) Invalid DOIs return `status: "error"` and unknown DOIs `status: "not_found"`; neither is charged. The run's `OUTPUT` record has the totals (papers, duplicates skipped, OpenAlex requests, seconds). Citations are generated from OpenAlex metadata on a best-effort basis: family names are split from display names (particles like *van der* and *da* are kept), and page ranges, volume and issue appear only when OpenAlex has them. Check them before formal submission. ### How much does it cost? Pay per event: **US$ 0.001 per paper returned** (`paper` event), i.e. US$ 1 per 1,000 papers. Invalid or unknown DOIs, duplicates and failed runs are free. How it was set: the Actor runs with 256 MB and OpenAlex returns 200 papers per request, so 1,000 papers cost about US$ 0.0003 in Apify compute. Other OpenAlex Actors in the Store charge from about US$ 0.0004 to US$ 0.005 per paper, several with start fees; this one sits in the middle with no start fee while adding APA/BibTeX citations and a Markdown card. The run needs only its own default dataset and key-value store, so it works with Apify's limited permissions. **$0.001 per paper** (`paper` event, pay per event). Charged once per paper returned. Invalid or unknown DOIs, duplicates and errors are free. | You get | Free tier | Bronze tier (10% off) | Gold tier (30% off) | |---|---|---|---| | 100 papers | $0.10 | $0.09 | $0.07 | | 1,000 papers | $1.00 | $0.90 | $0.70 | | 10,000 papers | $10.00 | $9.00 | $7.00 | Discounts follow your Apify subscription tier: Bronze 10%, Silver 20%, Gold and above 30%. No subscription to this Actor and no charge for platform usage: you pay only for results. The Apify Free plan includes $5 of monthly credit, enough for about **5,000 papers** at the list price. You can cap the cost of any run with **Maximum cost per run**; the Actor stops when it is reached. ### Data source [OpenAlex](https://openalex.org), a free and open index of scholarly works run by the nonprofit OurResearch. OpenAlex data is released under **CC0** (public domain), so it can be reused for any purpose, commercial included; attribution is appreciated and given here. The Actor calls the official REST API (`api.openalex.org`) and follows its rules: `mailto` for the polite pool, cursor paging, `select` to request only needed fields, and back-off on `429`. The free tier has a daily credit budget (each list request of up to 200 papers costs 10 credits); if it runs out, the run stops cleanly with a message, and you can pass your own `openalexApiKey`. If OpenAlex cannot be reached at all, the run fails with a clear message after five retries instead of returning partial data silently. Abstracts are reconstructed from the inverted index OpenAlex publishes; coverage is higher for recent works (about 60% of 2022 works have one). Authors' names, ORCID and institutions are public authorship metadata; raw affiliation strings (which sometimes contain e-mail addresses) are not included. ### More questions #### Does it return the full text of the papers? No. It returns metadata, the abstract and the best open-access `pdfUrl` with its `license`. To put full papers in a RAG index, download the PDFs from `pdfUrl` (filter with `openAccessOnly`, on by default) and convert them, for example with our [Documents to Markdown](https://apify.com/br_data_hub/docs-to-markdown) Actor. The `markdown` card is meant as a compact, citable record per paper. #### Why do some papers have no abstract? OpenAlex publishes abstracts only as an inverted index, and not every work has one; coverage is higher for recent works. The Actor rebuilds the text when the index exists, otherwise `abstract` is `null` and the Markdown card says no abstract is available. Turn on `hasAbstract` to keep only papers with an abstract, which is usually what a RAG index needs. #### How do I chunk the results for a vector database? Each paper is already one self-contained chunk: the `markdown` card holds the title, up to 10 authors with institutions, venue and year, DOI, citations, open-access link, topics, abstract and APA citation. Embed `markdown` (or `title` + `abstract`) and keep `doi`, `publicationYear`, `citedByCount` and `topics` as metadata for filtering and citing. #### How fresh is the data? Every run queries the live OpenAlex API, so results are as current as OpenAlex, and citation counts change over time. Use `sort: "newest"` with a `yearFrom` to monitor a topic on a schedule. #### When only the year is known, what is the publication date? OpenAlex then sets `publicationDate` to January 1 of that year. Use `publicationYear` when you need a reliable value. #### How do DOI lookups work? Put DOIs in `dois` (bare `10.xxxx/...` or `https://doi.org/...`). The query and filters are ignored in this mode, repeated DOIs are looked up once, inputs that are not DOIs come back with `status: "error"`, and DOIs that OpenAlex does not have come back with `status: "not_found"`. Both are free. #### What are the limits? Up to 100,000 papers per run, read 200 per request with cursor paging. OpenAlex's free tier has a daily credit budget; when it runs out the run stops cleanly with a message, and passing your own `openalexApiKey` raises the limit. Without a query, results are sorted by most cited; `relevance` needs a query. #### Can I combine keywords with fields and topics? Yes. `query` supports `AND`, `OR`, `NOT` and `"exact phrases"`, and is combined with every filter: years, open access, types, `fields` (OpenAlex's 26 research areas), `topics` (ids like `T10028` or names, matched to the closest topic and shown in the log), language, minimum citations and retracted papers (excluded by default). ### Use it via API Run it from any language and get the results as JSON. Replace `` with your [Apify API token](https://console.apify.com/settings/integrations). ```bash curl -X POST "https://api.apify.com/v2/acts/br_data_hub~openalex-research-search/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{"query": "retrieval augmented generation"}' ``` ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("br_data_hub/openalex-research-search").call(run_input={'query': 'retrieval augmented generation'}) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` You can also schedule runs, send results to webhooks, or connect the Actor to Make, Zapier, n8n, Google Sheets and other [integrations](https://docs.apify.com/platform/integrations). ### Use it with AI agents (MCP) This Actor is ready for AI agents: typed input and output schemas, pay-per-event pricing, limited permissions and short runs. - **Apify MCP server:** add `https://mcp.apify.com/?tools=br_data_hub/openalex-research-search` to Claude, ChatGPT, Cursor, VS Code or any MCP client, and the agent can call this Actor as a tool. - **Agent frameworks:** call it from LangChain, LlamaIndex, CrewAI or the OpenAI Agents SDK through the Apify integrations, or with the API call above. - Results come as structured JSON with stable field names, documented in the **Output** tab. ### FAQ #### Where does the data come from? [OpenAlex](https://openalex.org), a free and open index of scholarly works run by the nonprofit OurResearch. OpenAlex data is released under **CC0** (public domain), so it can be reused for any purpose, commercial included; attribution is appreciated and given here. The Actor calls the official REST API (`api.openalex.org`) and follows its rules: `mailto` for the polite pool, cursor paging, `select` to request only needed fields, and back-off on `429`. The free tier has a daily credit budget (each list request of up to 200 papers costs 10 credits); if it runs out, the run stops cleanly with a message, and you can pass your own `openalexApiKey`. If OpenAlex cannot be reached at all, the run fails with a clear message after five retries instead of returning partial data silently. #### How much does it cost? $0.001 per paper. Discounts follow your Apify subscription tier: Bronze 10%, Silver 20%, Gold and above 30%. See **How much does it cost?** above for examples. #### Do I pay for errors or empty results? No. Charged once per paper returned. Invalid or unknown DOIs, duplicates and errors are free. #### Can I run it on a schedule or connect it to other tools? Yes. Use Apify schedules to run it daily or weekly, webhooks to get notified, and integrations such as Make, Zapier, n8n and Google Sheets. Everything also works through the API. #### Can AI agents use it? Yes. It works as a tool in the Apify MCP server and in agent frameworks, and AI agents can pay per event. See **Use it with AI agents (MCP)**. #### Is it legal to use this data? The Actor reads only public sources. You are responsible for how you use the data and for complying with the source's terms and with privacy laws such as GDPR. #### I found a bug or need a feature. What should I do? Open an issue in the **Issues** tab. We answer within 14 days, usually much sooner. ### More Actors from BR Data Hub | Actor | What it does | |---|---| | [Documents to Markdown for RAG (Docling)](https://apify.com/br_data_hub/docs-to-markdown) | Convert PDF and DOCX files to clean Markdown with Docling: page count, detected tables, metadata and optional | | [Website to llms.txt Generator](https://apify.com/br_data_hub/website-to-llms-txt) | Crawl one website (robots.txt and sitemap aware), generate spec-compliant llms.txt and llms-full.txt files, au | | [RSS & Atom Feed Reader with Full Text](https://apify.com/br_data_hub/rss-full-text-feed) | Read RSS, Atom and JSON Feed (or find the feed of any website) and get clean items with ISO dates, full articl | | [Brazil CNPJ Lookup API (Consulta CNPJ)](https://apify.com/br_data_hub/br-cnpj-lookup) | Look up Brazilian companies by CNPJ: registration status, partners (masked CPF), activities, tax regime and sc | See all our Actors at [apify.com/br_data_hub](https://apify.com/br_data_hub). ### Usar em português Busque artigos científicos a partir dos dados do OpenAlex (mais de 250 milhões de trabalhos, dados em domínio público, CC0) por palavra-chave, ano, acesso aberto, tipo, área, tópico, idioma e número mínimo de citações, ou informe uma lista de DOIs. Cada artigo vem com autores e instituições, periódico, ano, DOI, citações, tópicos, link do PDF aberto, resumo em texto (reconstruído do índice invertido do OpenAlex), citação pronta em APA e BibTeX e um campo `markdown` pronto para RAG e agentes de pesquisa. Resultados repetidos pelo mesmo DOI são removidos. A cobrança é por artigo entregue (`paper`, US$ 0,001); DOIs inválidos ou não encontrados não são cobrados. Ferramenta independente, sem afiliação com o OpenAlex ou a OurResearch. **Quanto custa:** $0.001 por resultado (`paper`); 1.000 resultados saem por $1.00. Desconto pelo nível da assinatura Apify: Bronze 10%, Silver 20%, Gold ou acima 30%. Erros e consultas sem resultado não são cobrados. Use também pela API ou por agentes de IA no servidor MCP da Apify (`https://mcp.apify.com/?tools=br_data_hub/openalex-research-search`). # Actor input Schema ## `query` (type: `string`): Type words to find in titles, abstracts and full text, e.g. retrieval augmented generation. Use AND, OR, NOT in uppercase and "exact phrases" in double quotes. Leave empty to list papers by filters only. ## `dois` (type: `array`): Enter DOIs to look up instead of searching, one per line, as 10.xxxx/... or https://doi.org/... links. When set, the query and filters are ignored; unknown DOIs come back as not_found and are free. ## `yearFrom` (type: `integer`): Set the first publication year to include, e.g. 2023. ## `yearTo` (type: `integer`): Set the last publication year to include. Leave empty for up to now. ## `openAccessOnly` (type: `boolean`): Keep on to return only papers free to read somewhere (gold, green, hybrid, bronze or diamond). ## `types` (type: `array`): Pick the OpenAlex work types to keep, e.g. Article or Preprint. Leave empty for all. ## `fields` (type: `array`): Pick fields of the paper's main topic (OpenAlex's 26 fields, based on Scopus ASJC), e.g. Computer Science. Leave empty for all. ## `topics` (type: `array`): Enter OpenAlex topics as ids (T10028) or names ("Natural Language Processing Techniques"), one per line. Names are matched to the closest topic, shown in the log. Papers with any topic are returned. ## `minCitations` (type: `integer`): Set the minimum number of citations, e.g. 10. ## `language` (type: `string`): Type a two-letter ISO 639-1 language code, e.g. en, pt or es. Leave empty for all languages. ## `hasAbstract` (type: `boolean`): Turn on to skip papers for which OpenAlex has no abstract. Useful for RAG, where the abstract is the main text. ## `includeRetracted` (type: `boolean`): Turn on to keep retracted papers, flagged with isRetracted. They are left out by default. ## `sort` (type: `string`): Pick the order of results. Relevance needs a search query; without one, results are sorted by citations. ## `maxResults` (type: `integer`): Set the maximum number of papers to return in search mode, e.g. 25. Large lists are read 200 per request with cursor paging. ## `includeMarkdown` (type: `boolean`): Keep on to add a markdown field per paper (title, authors, venue, DOI, citations, abstract and APA citation) ready for embeddings or LLM context. ## `contactEmail` (type: `string`): Type an e-mail to send to OpenAlex as mailto, as they ask, so they can reach you if a request misbehaves. Not stored in the results. Optional. ## `openalexApiKey` (type: `string`): Paste your own OpenAlex API key for higher daily limits. Without it the shared free daily limit applies. Optional. ## Actor input object example ```json { "query": "retrieval augmented generation", "yearFrom": 2023, "openAccessOnly": true, "hasAbstract": false, "includeRetracted": false, "sort": "relevance", "maxResults": 25, "includeMarkdown": true } ``` # Actor output Schema ## `dataset` (type: `string`): Dataset with all results ## `files` (type: `string`): Counts for the run (papers, duplicates, invalid DOIs, requests, time) # 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 = { "query": "retrieval augmented generation" }; // Run the Actor and wait for it to finish const run = await client.actor("br_data_hub/openalex-research-search").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 = { "query": "retrieval augmented generation" } # Run the Actor and wait for it to finish run = client.actor("br_data_hub/openalex-research-search").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 '{ "query": "retrieval augmented generation" }' | apify call br_data_hub/openalex-research-search --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,br_data_hub/openalex-research-search" } } } ``` 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/7ciIG47SiBWPSbiWF/builds/IF8bcCenEkymxmar8/openapi.json