# PubMed Scraper — Medical Articles, Abstracts & New Paper Alerts (`magnova/pubmed-scraper`) Actor

Search PubMed — 40M+ medical and life-science articles — by keyword, author, journal or date. Get titles, abstracts, authors, PMID, DOI and MeSH terms as clean records. No API key needed. $0.002 per article. New-paper alerts on any saved search.

- **URL**: https://apify.com/magnova/pubmed-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Automation, Business, Education
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 articles

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

## PubMed Scraper — Medical Articles, Abstracts & New Paper Alerts

Search **PubMed** — the U.S. National Library of Medicine's index of **40M+ biomedical and life-science citations** — and get clean, structured article records: title, abstract, the author byline as published, journal, publication date, PMID, DOI, PubMed Central id, publication types and MeSH terms.

The data comes from NCBI's **official E-utilities API** — the same public interface NLM provides for programmatic access. **No API key, no account, no login.** You pay **$0.002 per article delivered** and nothing else: no start fee, no charge for quiet days, duplicates or errors.

Three ways to use it: pull the current corpus for any search (backfills, evidence corpora, RAG pipelines), schedule it with a monitor store and receive **only the new papers** for that search, or drive it statelessly from Make/Zapier with a `publishedSince` cursor.

### Sample output

A real record, delivered exactly in this shape:

```json
{
  "recordType": "ARTICLE",
  "pmid": "42868808",
  "articleUrl": "https://pubmed.ncbi.nlm.nih.gov/42868808/",
  "articleTitle": "Multifunctional nanoflower-assisted catalytic hairpin assembly enables extracellular vesicles derived-microRNAs profiling for colorectal cancer diagnosis.",
  "abstractText": "The clinical translation of small extracellular vesicle-derived microRNAs (sEV-miRNAs) for early colorectal cancer (CRC) diagnosis is often limited by their low abundance and complexity of biological fluids. Herein, we developed an ultrasensitive electrochemical platform based on multifunctional DNA nanoflower-assisted catalytic hairpin assembly (NF-CHA) for sEV-miRNAs detection. The NF acts as a localized scaffold to accelerate CHA kinetics and load abundant signal reporter. As a result, the NF-CHA strategy enables the platform achieving a limit of detection of 23.65 aM. To improve diagnostic performance, we employed different sEV-miRNAs combination and machine learning (ML) algorithms, achieving an area under the curve (AUC) of 0.996 for distinguishing early-stage CRC from healthy donors in clinical samples. Therefore, the electrochemical platform holds a great promise as a robust tool for CRC early diagnosis.",
  "authors": ["Zhang Xiaohe", "Pan Jiezhen", "Lin Yuanhong", "Lin Zhixuan", "Zhu Yiping", "Yang Chao", "Zhang Ye", "Yan Lizhi", "Li Zihua", "Yan Xiaohui"],
  "journalTitle": "Talanta",
  "publicationDate": "2026-10-07",
  "doi": "10.1016/j.talanta.2026.130751",
  "publicationTypes": ["Journal Article"],
  "meshTerms": ["Humans", "Colorectal Neoplasms", "MicroRNAs", "Extracellular Vesicles", "Electrochemical Techniques", "Biosensing Techniques", "DNA Nanostructures", "Catalysis", "Machine Learning", "Limit of Detection"]
}
```

Structured abstracts keep their section labels (BACKGROUND, METHODS, RESULTS, …), exactly as PubMed renders them.

### What you get

Every delivered ARTICLE record is built from the citation exactly as published:

| Field | What it is | Coverage |
|---|---|---|
| `pmid` | The article's PubMed identifier | Every record |
| `articleUrl` | The article's page on PubMed | Every record |
| `articleTitle` | The title as published | ≥95% of records |
| `abstractText` | The abstract, with its section labels (BACKGROUND, METHODS, …) where the article has one | Most modern records; many older records have no abstract — the field is absent then, never invented |
| `authors` | The published byline: "LastName ForeName" per author, group authors by their published group name. Affiliations are never included | ≥95% of records |
| `journalTitle` | The full journal title | ≥95% of records |
| `publicationDate` | The electronic publication date where the article has one, else the journal issue date. Windows and cursors are enforced on exactly this date | Every record (oldest records may carry year or year-month precision) |
| `doi` | The Digital Object Identifier | Where the record carries one (near-universal on post-2000 articles) |
| `pmcId` | The PubMed Central id | Where the article is archived in PubMed Central |
| `publicationTypes` | PubMed's type labels — Journal Article, Review, Randomized Controlled Trial, … | ≥90% of records |
| `meshTerms` | The MeSH descriptor names the article is indexed with | Where indexed — MeSH indexing lags publication by days to weeks, so the freshest articles often have none yet |

Each run ends with one **SUMMARY** record (counts, what was skipped and why, whether the run stopped at a cap) that is never charged. If PubMed cannot be read at all, the run delivers one **ERROR** record plus the SUMMARY and ends normally — a broken source never looks like "no new papers", and in monitoring mode the state is not advanced, so the next run catches up.

### Three ways to run it

1. **Corpus search (default).** A run delivers the current matching articles, newest first, up to your per-run cap — the backfill is the first-run sale. Every delivered article is charged; nothing else is.
2. **Monitoring mode (only-new).** Pick one of your key-value stores as the *Monitor state store* and schedule the run. The first run delivers the baseline corpus; later runs deliver only articles the store hasn't seen. With **Start monitoring silently** on, the first run instead remembers the current matches without delivering or charging anything, and only genuinely new papers are ever delivered. Use one store per saved search.
3. **Cursor mode (stateless).** Hold the state in your own workflow instead: pass `publishedSince` (e.g. `"2026-11-01"`) and only articles published on or after that date are delivered — boundary-inclusive, compared by day.

### Inputs

| Input | What it does |
|---|---|
| Search terms | The topic, condition, drug or technique. Full PubMed search syntax works — field tags, AND/OR/NOT, quoted phrases |
| Authors | Byline filter, "Surname Initials" (e.g. `Fauci AS`). Several names combine with OR |
| Journals | Full journal titles as PubMed indexes them (e.g. `Nature`, `Lancet`). Several combine with OR |
| Publication types | e.g. `Review`, `Clinical Trial`, `Meta-Analysis`, `Randomized Controlled Trial`. Several combine with OR |
| Date from / Date to | Publication window, either side optional |
| Published on/after | The stateless cursor described above |
| Monitor state store | Your key-value store that remembers seen articles across runs |
| Start monitoring silently | Skip the baseline delivery on the first monitored run |
| Maximum articles per run | Hard cap on delivered (charged) articles, 1–10,000. Default 250 |
| Maximum total charge per run | Optional USD hard stop; undelivered new articles stay unseen for the next run |

Filters combine with AND across groups (a search term **and** an author **and** a journal), OR within a group. Results are always newest-first by publication date.

### Pricing

**$0.002 per article delivered** — that's **$2.00 per 1,000 articles**. Tier discounts apply automatically: SILVER pays $0.0017/article, GOLD and above $0.0014. No start fee, no per-run fee.

A worked example: a research team watching "glioblastoma immunotherapy" on a daily schedule sees roughly 5–15 new papers a day — call it 300 a month. The initial baseline pull of the recent corpus might be 1,000 articles ($2.00 once); the monitoring runs then cost about **$0.60/month**. A one-off evidence corpus of 5,000 randomized trials costs $10.00, once.

**Not charged:**

- The run SUMMARY record, and ERROR records when PubMed can't be read
- Articles the monitor store has already seen (duplicates are skipped free)
- Articles filtered out by your date window or the `publishedSince` cursor
- Articles silently seeded on a `monitorOnlyNew` first run
- Anything on a run that stops at your maximum charge — undelivered articles stay unseen and are delivered by the next run instead

### Examples

- **Literature backfill:** search terms `machine learning`, max results 250 → the 250 newest ML-in-medicine articles with abstracts, ready for screening or a RAG index.
- **Trial corpus:** search terms `diabetes`, publication type `Randomized Controlled Trial`, max results 5,000 → an evidence corpus for $10.00.
- **Author watch:** author `Fauci AS` + a monitor store, scheduled daily → only that author's new papers, $0.00 on quiet days.
- **Journal feed:** journal `Nature` → the newest Nature articles as structured records for a digest.
- **Systematic-review sweep:** search terms with full PubMed syntax — `(sepsis[Title/Abstract]) AND (machine learning)` — plus a date window for the review's coverage period.

### PubMed API

This Actor is a ready-made PubMed API: it wraps NCBI's E-utilities (esearch + efetch) with the parts production use needs and the raw API leaves to you — pagination over the history server, batched fetches, polite pacing inside NCBI's keyless rate limits with backoff, labelled-abstract assembly, date-precedence normalisation (electronic date vs issue date), dedupe across runs, and pay-per-article delivery caps. Call it from the Apify API, a schedule, Make/Zapier, or any MCP client.

### Searching patents or trademarks instead?

This Actor covers the medical literature. For inventions and brands, see the sibling Magnova actors built on the same template: Google Patents Scraper (patent publications) and USPTO Trademark Search (US trademarks).

### Use cases

- **Systematic reviews & evidence synthesis** — reproducible, date-bounded corpora with full abstracts for screening tools.
- **RAG / LLM pipelines** — fresh, deduplicated article records with stable PMIDs as document keys.
- **Competitive & pipeline intelligence** — watch a drug, a device class or a competitor's authors; get only what's new.
- **Journal clubs & digests** — scheduled newest-first feeds by topic, journal or author.
- **Medical information teams** — new-paper alerts on a product's whole literature footprint.

### Using this Actor with AI agents (MCP)

The Actor is agent-ready: a minimal input (search terms alone will do), structured records with stable identifiers, and deterministic newest-first ordering. Connect it through Apify's MCP server and an agent can search the literature, pull an abstract corpus, or maintain a standing new-paper watch without any custom code.

### FAQ

**Is this the full text of the articles?** No — PubMed is a citation index. You get the citation and the abstract where the article has one, plus the PubMed page and the DOI, which lead to the full text at the publisher or in PubMed Central (the `pmcId` tells you when it's there).

**Why does a record have no abstract?** Many older records were indexed without one, and journal front matter — letters, errata, editorials — usually has none either. The field is simply absent: on research-article searches coverage runs above 98%, and it falls the further back (or the more front-matter-heavy) the corpus gets. Nothing is ever reconstructed or summarised in its place.

**Why does a brand-new article have no MeSH terms?** MeSH indexing happens days to weeks after a record appears. Re-run later and the same article arrives indexed — in monitoring mode it isn't re-delivered, so pull the corpus again if you need the terms.

**Which date counts for the window and the cursor?** Each record ships one `publicationDate` — the electronic publication date when the article has one, otherwise the journal issue date — and windows and cursors are enforced on exactly that date, so a delivered set never contains a record whose shipped date falls outside your window. One deliberate difference from PubMed's own website search: PubMed's date filter *also* matches a paper whose journal issue falls in your window even when it was published electronically earlier. This Actor dates such a paper by its electronic publication, so it belongs to the earlier window here. The SUMMARY's `filteredOutDate` count shows how many search matches were held back by this rule.

**How does only-new detection work?** By PMID, remembered in *your* key-value store — never in a storage you can't see or take with you. Nothing in the store leaves your account.

**What happens if PubMed is down or rate-limits?** The run retries with backoff, then delivers an ERROR record and a SUMMARY, charges nothing for undelivered articles, and does not advance the monitor state — the next scheduled run catches up automatically.

### Legal

PubMed is a public database of the U.S. National Library of Medicine (NLM), and this Actor reads it through NCBI's official E-utilities API, as published, with no login and no access-control bypass. Records carry published bibliographic metadata only — article titles, abstracts, journal data and author bylines as printed on the articles themselves; author affiliations are never read, and no personal data beyond the published byline is collected or shipped.

***

*Built by Magnova. One of a family of official-source search actors — corpus first, only-new alerts on top, pay per record, no start fee.*

# Actor input Schema

## `authors` (type: `array`):

Optional author filter in PubMed's byline format, surname + initials (e.g. "Fauci AS", "Smith J"). Several names are combined with OR. Leave empty for all authors.

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

Optional window start (ISO date, e.g. "2026-10-01"): only articles published on or after this date. The publication date is the electronic date when the article has one, else the journal issue date, and the window is enforced on exactly that date.

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

Optional window end (ISO date, e.g. "2026-10-31"): only articles published on or before this date. May be given with or without Date from.

## `journals` (type: `array`):

Optional journal filter: only articles published in these journals, by their full title as PubMed indexes it (e.g. "Nature", "Lancet", "New England Journal of Medicine"). Several titles are combined with OR. Leave empty for all journals.

## `maxResults` (type: `integer`):

Hard cap on articles delivered (and charged) in one run. Results come back newest first (by publication date), so a capped run delivers the most recent matches. Articles a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they still fall in its window.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged articles reach this amount (checked conservatively at the highest per-article price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new articles stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the search's current articles as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current articles without delivering or charging anything, and only articles published afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which articles it has already seen — this is what makes only-new delivery work across runs. Use one store per saved search. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the search's articles as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every article it processed (including ones outside the window), so widening the window later does not re-deliver old articles.

## `publicationTypes` (type: `array`):

Optional filter by PubMed publication type (e.g. "Review", "Clinical Trial", "Meta-Analysis", "Randomized Controlled Trial", "Case Reports"). Several types are combined with OR. Leave empty for all types.

## `publishedSince` (type: `string`):

Optional stateless cursor for workflow tools (Make, Zapier, your own scheduler) that hold state themselves: only articles published on this ISO date or later are delivered — for example "2026-11-01" or "2026-11-01T00:00:00Z". Publication dates compare by day, boundary-inclusive. The cursor raises the window start; it does not extend the window end. Leave empty for the normal window behavior.

## `searchTerms` (type: `string`):

What to search for in PubMed — a topic, a condition, a drug, a technique (e.g. "machine learning", "glioblastoma immunotherapy"). Full PubMed search syntax is supported, including field tags, AND/OR/NOT and quoted phrases. Combined with the filters below using AND. Leave empty to search by author, journal or publication type alone.

## Actor input object example

```json
{
  "authors": [
    "Fauci AS"
  ],
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-31",
  "journals": [
    "Nature"
  ],
  "maxResults": 250,
  "maxTotalChargeUsd": 1,
  "monitorOnlyNew": false,
  "publicationTypes": [
    "Review"
  ],
  "publishedSince": "2026-11-01",
  "searchTerms": "machine learning"
}
```

# Actor output Schema

## `results` (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 = {
    "maxResults": 250,
    "monitorOnlyNew": false,
    "searchTerms": "machine learning"
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/pubmed-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 = {
    "maxResults": 250,
    "monitorOnlyNew": False,
    "searchTerms": "machine learning",
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/pubmed-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 '{
  "maxResults": 250,
  "monitorOnlyNew": false,
  "searchTerms": "machine learning"
}' |
apify call magnova/pubmed-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/pubmed-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/ubX3mXR1bRV8Sbv0p/builds/v6yn87iukj37Rgyz0/openapi.json
