# PubMed Articles Scraper: Abstracts and Authors | $1/1K (`one_dollar_store/pubmed-articles-scraper`) Actor

$1 per 1,000 results, platform usage included. PubMed articles for any search: PMID, title, abstract, authors and affiliations, journal, date, DOI, PMC id, MeSH terms and keywords. Official NCBI E-utilities, no key. Goes past 10,000 records by date range.

- **URL**: https://apify.com/one_dollar_store/pubmed-articles-scraper.md
- **Developed by:** [One Dollar Store](https://apify.com/one_dollar_store) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## PubMed Articles Scraper: Abstracts, Authors and MeSH Terms

**$1 per 1,000 articles. Platform usage included. No rental, no minimum.**

[Open it in Apify Console](https://console.apify.com/actors/jTCiAnbkJy3yZoGah/input)

### What it costs

| Articles | Price |
|---|---|
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

Plus $0.001 per run. One flat price, platform usage included, so there is no separate compute or proxy bill. A weekly pull of 500 new articles on one topic costs about $0.50 per run, or about $2 a month.

### Why use it

- **Complete records.** PMID, title, abstract, every author with affiliations, journal, dates, DOI, PMC id, publication types, MeSH terms, keywords, chemicals and grants.
- **Past the 9,999 limit.** PubMed search returns at most the first 9,999 matches. When you ask for more, the actor reads the search in publication date windows, newest first. A test run returned 10,100 articles for a search with 10,935 matches.
- **PubMed search syntax.** Field tags and operators work as on the website, for example `crispr[Title/Abstract] AND review[pt]`.
- **Lists of PMIDs.** Paste PMIDs and get one record each, next to or instead of searches.
- **Polite to NCBI.** The actor keeps under 3 requests a second and backs off when NCBI says slow down. No API key is needed.

### Quick start

1. Open the actor, type a search such as `CRISPR gene therapy`, press **Start**.
2. Or paste this input:

```json
{ "queries": ["CRISPR gene therapy"], "dateFrom": "2025-01-01", "onlyWithAbstract": true, "maxItems": 200 }
```

3. Download the results as JSON, CSV or Excel, or read them through the API.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/one_dollar_store~pubmed-articles-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["CRISPR gene therapy"], "maxItems": 100}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("one_dollar_store/pubmed-articles-scraper").call(
    run_input={"queries": ["CRISPR gene therapy"], "maxItems": 100}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["pmid"], item["publicationDate"], item["title"])
```

### Use it from an AI assistant

Claude, ChatGPT, Cursor and other assistants can call this actor through Apify's MCP server. Add it with this server address:

```
https://mcp.apify.com?tools=one_dollar_store/pubmed-articles-scraper
```

Then ask, for example: "Get the 50 newest PubMed articles about CAR T cell therapy with their abstracts."

### Switching from another PubMed actor

Most PubMed actors take a search query and a result limit. Here they are `queries` (a list, so one run can cover many searches) and `maxItems`. The core output fields are `pmid`, `title`, `abstract`, `authors`, `journal`, `publicationDate`, `doi` and `meshTerms`.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `queries` | list of text | none | PubMed searches, one per line. Plain words or PubMed syntax with field tags and AND, OR, NOT. |
| `pmids` | list of text | none | PubMed IDs to look up directly. |
| `dateFrom`, `dateTo` | text | none | Publication date range as `2024-01-31`, `2024-01` or `2024`. |
| `sort` | text | `date_added` | `date_added` (newest in PubMed first), `relevance` or `pub_date`. |
| `onlyWithAbstract` | true or false | false | Skip records without an abstract. |
| `maxItemsPerQuery` | number | 0 | Optional cap per search, so one big search cannot use the whole run. 0 means none. |
| `ncbiApiKey` | text | none | Optional. A free NCBI key lifts the rate limit from 3 to 10 requests a second. |
| `maxItems` | number | 100 | Total articles for the run. Minimum 10. |

Give at least one search or PMID. Example:

```json
{
  "queries": ["\"base editing\"[Title/Abstract]", "prime editing[Title/Abstract]"],
  "dateFrom": "2024-01-01",
  "onlyWithAbstract": true,
  "maxItemsPerQuery": 500,
  "maxItems": 1000
}
```

### Output fields

| Field | Meaning |
|---|---|
| `pmid`, `url` | PubMed ID and the PubMed page. |
| `title`, `abstract` | Title and abstract. Structured abstracts keep their section labels, such as `BACKGROUND:`. |
| `authors`, `authorCount`, `firstAuthor`, `lastAuthor` | Author names as full names. |
| `affiliations`, `orcids` | Unique author affiliations and ORCID ids as printed in the record (up to 40 each). |
| `journal`, `journalAbbreviation`, `issn`, `volume`, `issue`, `pages` | Where it was published. |
| `publicationDate`, `electronicDate`, `addedToPubmed` | Dates as `2024-03-15`, `2024-03` or `2024`, depending on what the journal gave. |
| `doi`, `pmcid` | DOI and PubMed Central id, when there is one. |
| `publicationTypes`, `languages` | For example `Journal Article`, `Review`, `eng`. |
| `meshTerms`, `meshMajorTerms` | MeSH headings, and the ones marked as a major topic. |
| `keywords`, `chemicals`, `grants` | Author keywords, substances, and grant ids with agency. |
| `recordType`, `searchQuery` | `article` or `book`, and which search found it. |

Fields a record does not have are left out.

### Sample results

Real rows from a test run on 9 October 2026, with author lists and abstracts shortened.

```json
[
  {"pmid": "42838939", "recordType": "article", "title": "Telomere variant sequences encode the genetic blueprint for allele-specific telomere length.",
   "authors": ["Xiaoran Chai", "LaiFong Poon", "Hengrui Liu", "..."], "authorCount": 17, "journal": "Nature communications",
   "publicationDate": "2026-09-07", "doi": "10.1038/s41467-026-77310-9", "pmcid": "PMC13642928", "publicationTypes": ["Journal Article"],
   "meshTerms": ["Humans", "Telomere", "Alleles", "Telomere Homeostasis"],
   "abstract": "The ends of human chromosomes are capped by specialized nucleoprotein structures, termed telomeres, which are essential for genome stability. ...",
   "url": "https://pubmed.ncbi.nlm.nih.gov/42838939/", "searchQuery": "CRISPR gene therapy"},
  {"pmid": "42837422", "recordType": "article", "title": "The Genomic Equity Accessibility Framework (GEAF): A dimensionally consistent framework for modeling affordability and equity in genomic and regenerative therapies.",
   "authors": ["Peter Oloche David"], "authorCount": 1, "journal": "PloS one", "publicationDate": "2026",
   "doi": "10.1371/journal.pone.0359782", "pmcid": "PMC13641711", "publicationTypes": ["Journal Article"],
   "meshTerms": ["Humans", "Genomics", "Regenerative Medicine", "Gene Editing"],
   "abstract": "BACKGROUND: Advances in CRISPR-based gene editing and stem cell-derived embryo models have created substantial biomedical opportunity ...",
   "url": "https://pubmed.ncbi.nlm.nih.gov/42837422/", "searchQuery": "CRISPR gene therapy"}
]
```

### Limits

- **9,999 records per search window.** PubMed will not return more than the first 9,999 matches of one search. Bigger requests are split by publication date. If a single day holds more than 9,999 matches (some journals date issues January 1), only the first 9,999 of that day are returned and the log says so.
- **Pace.** NCBI allows 3 requests a second without a key. A test run delivered 10,100 articles in about 32 minutes, roughly 5 a second. The default run timeout is one hour, so very large pulls need a longer timeout or an NCBI key.
- **Shared addresses.** NCBI counts requests per address, and Apify addresses are shared. If NCBI answers "slow down", the actor waits and tries again, up to seven times. A free NCBI key in `ncbiApiKey` avoids this.
- **Abstracts, not full text.** Some records have no abstract (46 of the first 50 results in one test did), and the actor does not read full articles or reference lists.
- **MeSH comes later.** New records get MeSH terms after NLM indexes them. In one test of the 50 newest results, 18 had MeSH terms.
- **Dates.** `publicationDate` is what the journal gave, which can be only a year or a year and month.
- **Books.** A few PubMed records are Bookshelf entries. They come back with `recordType` set to `book` and fewer fields.

### FAQ

**How much does it cost to scrape 10,000 PubMed articles?**
$10, plus $0.001 for each run.

**Do I pay for compute or proxy on top?**
No. Platform usage is included in the $1 per 1,000 price. NCBI is read directly, so no proxy is used.

**Where does the data come from?**
From the official NCBI E-utilities (esearch to find articles, efetch to read them). No login is used, and the actor identifies itself to NCBI in the requests as the E-utilities rules ask.

**How do I get more than 10,000 results for one topic?**
Set `maxItems` above 10,000. The actor then reads the search in date windows, newest first. You can also set `dateFrom` and `dateTo` yourself and run one range at a time.

**How do I monitor a topic every week?**
Schedule a run with `dateFrom` set to a week ago, and use `pmid` to drop articles you already have.

**Is it legal?**
The actor reads public data only, with no login. Titles, authors and abstracts are bibliographic facts that PubMed shows to everyone, but abstracts can carry the publisher's copyright. Follow NCBI's data use policy, the publishers' terms and the law where you live, and do not republish text you do not have rights to.

**Is this an official PubMed or NCBI product?**
No. It is an independent tool and is not affiliated with or endorsed by NCBI, the National Library of Medicine or the US government.

**Do I need an Apify account?**
Yes. Actors run from an Apify account, and a free account is enough to start: it includes $5 of platform usage every month. You can [sign up here](https://www.apify.com?fpr=ymnoit). This is a referral link and it costs you nothing.

**Is there a limit on the free plan?**
Yes. A run started from a free plan account delivers the first 10 results, then ends with a message and a link to the plans. Any paid plan returns everything you ask for, up to your own limit. The price per result is the same on every plan.

### More from The One Dollar Store

Every actor here costs $1 per 1,000 results, platform usage included. See the whole store: https://apify.com/one_dollar_store

**Health and science**

- [NPI Provider Search](https://apify.com/one_dollar_store/npi-providers-search): US healthcare providers from the NPI registry.
- [ClinicalTrials.gov Scraper](https://apify.com/one_dollar_store/clinical-trials-search): Clinical studies by condition, drug or sponsor.
- [Product Recalls Scraper](https://apify.com/one_dollar_store/consumer-product-recalls-cpsc): US consumer product recalls from the CPSC.

**Google and search**

- [Google News Scraper](https://apify.com/one_dollar_store/google-news-articles-scraper): News articles by keyword, topic or country.

### Changelog

- October 2026: first release.

# Actor input Schema

## `queries` (type: `array`):

PubMed searches, one per line. Plain words work, and so do PubMed field tags and operators, for example: crispr\[Title/Abstract] AND review\[pt]. Each search is read on its own and repeats across searches are removed.

## `pmids` (type: `array`):

Look up articles by PubMed ID (PMID), one per line, for example 38000000. Can be used on its own or next to searches.

## `dateFrom` (type: `string`):

Earliest publication date, as 2024-01-31, 2024-01 or 2024. Leave empty for no start date.

## `dateTo` (type: `string`):

Latest publication date, as 2024-12-31, 2024-12 or 2024. Leave empty for no end date.

## `sort` (type: `string`):

Most recently added first is PubMed's own default. Searches that need date windows (more than 9,999 matches) are read newest window first.

## `onlyWithAbstract` (type: `boolean`):

Skip records that have no abstract (letters, comments, old articles).

## `maxItemsPerQuery` (type: `integer`):

Optional cap for each search, so one big search cannot use the whole run. 0 means no extra cap.

## `ncbiApiKey` (type: `string`):

Not needed. A free NCBI key raises the rate limit from 3 to 10 requests a second, which helps on very large pulls.

## `maxItems` (type: `integer`):

The run stops after this many articles in total. Minimum 10.

## Actor input object example

```json
{
  "queries": [
    "CRISPR gene therapy"
  ],
  "sort": "date_added",
  "onlyWithAbstract": false,
  "maxItemsPerQuery": 0,
  "maxItems": 50
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "CRISPR gene therapy"
    ],
    "sort": "date_added",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("one_dollar_store/pubmed-articles-scraper").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["CRISPR gene therapy"],
    "sort": "date_added",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("one_dollar_store/pubmed-articles-scraper").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 gene therapy"
  ],
  "sort": "date_added",
  "maxItems": 50
}' |
apify call one_dollar_store/pubmed-articles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,one_dollar_store/pubmed-articles-scraper"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/jTCiAnbkJy3yZoGah/builds/biT2OZ6EWOT2W94uf/openapi.json