# PubMed Articles Scraper 📚🎓 (`scrapestorm/pubmed-articles-scraper`)

Easily retrieve relevant academic articles from PubMed with this powerful scraper 🔍. Customize results with filters like max items to extract 🔢 and sorting options like "e.g Best match" 🏆. Ideal for medical research, scientific papers, and gathering references fast! 🌍

- **URL**: https://beta-securitybyobscurity.apify.com/scrapestorm/pubmed-articles-scraper.md
- **Developed by:** [Storm\_Scraper](https://beta-securitybyobscurity.apify.com/scrapestorm) (community)
- **Categories:** Integrations, Automation
- **Stats:** 14 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$18.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

# README

### PubMed Articles Scraper 📚✨

This PubMed Articles Scraper is designed to help you easily retrieve relevant academic articles based on your search query 🔍. You can customize the results with filters like the maximum number of items to extract 🔢 and sorting options such as "Best match" 🏆.

Whether you're researching medical topics, reviewing scientific papers, or gathering references, this tool gives you quick access to the most relevant articles on PubMed 🌍.

### Description 💯🎓

The PubMed Articles Scraper is your go-to tool for discovering academic research on PubMed. Simply enter a topic, keyword, or disease, and get tailored results with adjustable filters 🛠️. You can specify the maximum number of articles to extract (e.g., 30 articles) and the sorting preference (e.g., Best match) 🔍.

Retrieve detailed information about each article, including the title 📝, authors ✍️, journal details 📖, DOI 🔗, publication date 🗓️, and a direct link to the article 📑. This tool provides an efficient and streamlined way to gather relevant articles from PubMed.

### How many results can you extract using this PubMed Articles Scraper? 🔍

There is no limit to the number of articles you can extract 📊, as long as they match your search query and filter criteria.

You can specify how many results you wish to retrieve, for example, up to 100 articles 🔢.

### Key Features ✨

- Unlimited Results 🔢: Extract as many articles as needed, depending on your query and filters.

- Customizable Sorting Options 🔍: Choose how to sort your results, such as by “Best match” or by relevance.

- Detailed Article Info 📝: Extract key details such as article title, authors, publication date, journal info, DOI, and a direct link to the article.

- Search Flexibility 🔍: Specify any keyword, disease, or topic to find related academic articles.

### 💸 Pricing

This scraper operates on a monthly subscription basis, priced at $18.99/month.

### Using this PubMed Articles Scraper is simple and intuitive! Just follow these easy steps:

```
Enter your search query — for example, a keyword like "heart disease" 🔑.
Customize your filters: Choose the maximum number of articles to extract (e.g., 30 articles) and the sorting preference (e.g., Best match) 🔍.
Click the "Start" button to begin the scraping process 🚀.
Once completed, download the extracted data in your preferred format:
    JSON 📄
    CSV 📊
    XML 📑
    Excel 📈
    HTML 🌐
```

### Applications 🌟

```
Exploring online learning opportunities and enhancing skills 📚
Building learning paths for researchers, students, and professionals 🧑‍🏫
Analyzing course trends and learner preferences 📊
Evaluating course ratings, reviews, and duration 🏆
```

### Input Example for PubMed Articles Scraper 👌

The scraper accepts various parameters to customize the scraping process. Here’s how to structure your input JSON:

```
{
    "keyword": "Heart disease",
    "maxitems": 30,
    "sort_by": "Best match"
}


```

### Output Example from PubMed Articles Scraper 👌

Once the extraction is finished, the data will be stored in a dataset. You can download this data in various formats (JSON, CSV, XML, RSS, HTML Table).

Here is an example of the JSON output for an article:

```
{
  "title": "Heart Disease in Children.",
  "authors": "Garcia RU, Peddy SB.",
  "journal_date_doi": "Prim Care. 2018 Mar;45(1):143-154. doi: 10.1016/j.pop.2017.10.005.",
  "date": "2018",
  "doi": "10.1016/j.pop.2017.10.005.",
  "volume_issue": "45(1)",
  "pages": "143-154",
  "abstract": "More children than ever born with congenital heart disease (CHD) are growing into adulthood. Primary care providers play a key role in diagnosis, management, and referral of children with CHD because many common cardiac complaints (eg, feeding intolerance, cyanosis, \u2026",
  "link": "https://pubmed.ncbi.nlm.nih.gov/29406940/"
}


```

### Related Actors ⭐

If you're interested in other Google, social media scraper or real estate Actors:

- [Coursera Course Scraper 📚⚡](https://apify.com/scrapestorm/coursera-course-scraper)
- [Udemy Course Reviews Scraper 📖💬](https://apify.com/scrapestorm/udemy-course-reviews-scraper)
- [Google Scholar Scraper: Fast & Affordable (Rental) 📚⚡](https://apify.com/scrapestorm/google-scholar-scraper-fast-affordable-rental)
- [Google Scholar Scraper: Fast & Affordable (Pay Per Result) 📚⚡](https://apify.com/scrapestorm/google-scholar-scraper-fast-affordable-pay-per-result)
- [Google News Scraper Fast & Real-Time (Pay per results) 📰⚡](https://apify.com/scrapestorm/google-news-scraper-fast-real-time-pay-per-results)
- [Facebook Likes Scraper (Fast & Cheap) 👍 🌟](https://apify.com/scrapestorm/facebook-likes-scraper-fast-cheap)
- [Facebook Shares Scraper (Exclusive & Affordable) 🚀💡](https://apify.com/scrapestorm/facebook-shares-scraper-exclusive-affordable)
- [Facebook Followers & Following Scraper 📊👥](https://apify.com/scrapestorm/facebook-followers-following-scraper)
- [Facebook Comments Scraper (All-in-One) 💬](https://apify.com/scrapestorm/facebook-comments-scraper-all-in-one)
- [YouTube Scraper (By Keyword) - ⭐⭐⭐⭐⭐ Fast & cheap](https://apify.com/scrapestorm/youtube)
- [Youtube Channel Scraper](https://apify.com/scrapestorm/youtube-channel-scraper)
- [Youtube Shorts Scraper 📺 (Rental) - Fast & cheap](https://apify.com/scrapestorm/youtube-shorts-scraper-rental---fast-cheap)
- [Zillow (Find a Home Improvement Agent) 🛠️)](https://apify.com/scrapestorm/zillow-find-a-home-improvement-agent)
- [YouTube Transcript Video Scraper 📝 (⚡ Fast & 💸 Cheap)](https://apify.com/scrapestorm/youtube-transcript-videos)
- [Youtube Playlist Scraper 🎵 - Rental (Fast & cheap)](https://apify.com/scrapestorm/youtube-playlist-scraper---rental-fast-cheap)

***

### Can I use this PubMed Articles API in Python? 🎓

Yes, you can use the Apify API with Python.

To access the PubMed Articles Scraper via Python, use the apify-client PyPI package. You can find more details about the client in our Python Client documentation.

### 📫 Support

😊 Leave us a ⭐⭐⭐⭐⭐ if you are satisfied with the product!
🌍 For any questions, specific needs or issues, please reach out through Apify's platform or via email - [Storm\_Scraper 🌪️🌩️](https://apify.com/scrapestorm)

# Actor input Schema

## `keyword` (type: `string`):

The keyword or subject you wish to search articles for on Pubmed 🔍🎓

## `maxitems` (type: `integer`):

Maximum number of results you want to scrape 📊

## `sort_by` (type: `string`):

Select a Sort type 🌍

## Actor input object example

```json
{
  "keyword": "Heart disease",
  "maxitems": 100,
  "sort_by": "Best match"
}
```

# 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 = {
    "keyword": "Heart disease",
    "maxitems": 100,
    "sort_by": "Best match"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapestorm/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 = {
    "keyword": "Heart disease",
    "maxitems": 100,
    "sort_by": "Best match",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapestorm/pubmed-articles-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keyword": "Heart disease",
  "maxitems": 100,
  "sort_by": "Best match"
}' |
apify call scrapestorm/pubmed-articles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapestorm/pubmed-articles-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PubMed Articles Scraper 📚🎓",
        "description": "Easily retrieve relevant academic articles from PubMed with this powerful scraper 🔍. Customize results with filters like max items to extract 🔢 and sorting options like \"e.g Best match\" 🏆. Ideal for medical research, scientific papers, and gathering references fast! 🌍",
        "version": "0.0",
        "x-build-id": "K3kCBYnQ2WUJ5Q8iS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapestorm~pubmed-articles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapestorm-pubmed-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapestorm~pubmed-articles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapestorm-pubmed-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapestorm~pubmed-articles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapestorm-pubmed-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "The keyword or subject you wish to search articles for on Pubmed 🔍🎓",
                        "type": "string",
                        "description": "The keyword or subject you wish to search articles for on Pubmed 🔍🎓",
                        "default": "Heart disease"
                    },
                    "maxitems": {
                        "title": "Maximum number of results you want to scrape 📊",
                        "type": "integer",
                        "description": "Maximum number of results you want to scrape 📊",
                        "default": 100
                    },
                    "sort_by": {
                        "title": "Select a Sort type 🌍",
                        "enum": [
                            "Best match",
                            "Most recent",
                            "Publication date",
                            "First Author",
                            "Journal"
                        ],
                        "type": "string",
                        "description": "Select a Sort type 🌍",
                        "default": "Best match"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
