# Medium Scraper & API: Articles, Claps & Full Text Export (`s_actors/medium-scraper`) Actor

Scrape Medium without login: articles by tag (latest or most read of each month), keyword search, author, publication or link. Claps, responses, reading time, member-only flag, author followers and full text as Markdown. Date and claps filters, new articles alerts.

- **URL**: https://apify.com/s_actors/medium-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Social media, News, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.98 / 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

### Medium Scraper & API: Articles, Claps & Full Text Export

Export **Medium articles** with their real numbers: **claps, responses, reading time, word count, member-only flag, author followers** and the **full text as Markdown**. Get articles by **tag** (the latest, or the **most read of every month** back to any date), by **keyword search** (up to ~1 000 per query), the **whole history of an author or a publication**, or by **article link**. No Medium account, no browser, no 10-article RSS limit.

```json
{ "tags": ["python"], "tagSort": "top", "publishedAfter": "2026-07-01", "minClaps": 100 }
```

Filter by **date range**, **minimum claps** and **free / member-only**; articles you filter out are free. Schedule it with **Only new articles** to get every new article of a tag, an author or a keyword as an alert.

#### What you get

Real example, 25 October 2026: tag **python**, **Most read**, July to September 2026:

| published | title | author | publication | claps | responses | read min | member-only | claps / 1k followers |
|---|---|---|---|---|---|---|---|---|
| 2026-07-12 | Eigenvalues for People Who Slept Through Linear Algebra | Kamrun Nahar | Towards AI | 4,050 | 63 | 15 | yes | 1,202.9 |
| 2026-08-15 | How The Fast Fourier Transform Actually Works | Kamrun Nahar | Towards AI | 2,823 | 48 | 23 | yes | 838.4 |
| 2026-08-26 | Structuring 40 Million Documents into an Agentic Knowledge Graph | Fareed Khan | Level Up Coding | 1,753 | 22 | 58 | yes | 22.5 |
| 2026-07-15 | Building GLM 5.2 744B Model in C to Run on 25GB RAM | Fareed Khan | Level Up Coding | 1,408 | 8 | 72 | yes | 18.1 |
| 2026-09-21 | Jev Clearly Explained | Fareed Khan | Level Up Coding | 1,035 | 15 | 21 | yes | 13.3 |

Search **"vector database"**, with the text:

| title | author | published | claps | responses | read min | full text |
|---|---|---|---|---|---|---|
| Vector Databases Are Becoming a Feature, Not a Product | Tajamul Khan | 2026-10-20 | 292 | 2 | 4 | preview (member-only) |
| Vector Databases Explained: How AI Finds Relevant Information | Kehkasha | 2026-10-07 | 159 | 1 | 12 | 3,135 words |
| Vector Databases: When Search Needs Meaning, Not Just Keywords | Aliakbar Hosseinzadeh | 2026-10-19 | 73 | 1 | 5 | 1,169 words |

| Field | Description |
|---|---|
| `id`, `title`, `subtitle`, `url` | The article, its subtitle and link |
| `authorName`, `authorUsername`, `authorUrl`, `authorFollowers`, `authorBio` | The writer and their follower count |
| `publicationName`, `publicationSlug`, `publicationUrl`, `publicationFollowers` | The publication it appeared in (empty for personal posts) |
| `publishedAt`, `updatedAt` | First published and last updated (UTC) |
| `claps`, `clappers`, `responses` | Total claps, the number of people who clapped, the number of responses (comments) |
| `clapsPer1kFollowers` | Claps per 1,000 followers of the author: finds articles that did far better than the author's audience |
| `readingTimeMinutes`, `wordCount` | Reading time as Medium shows it ("12 min read") and the number of words |
| `isMemberOnly` | Behind the Medium paywall (member-only) |
| `language`, `tags`, `imageUrl` | Detected language, Medium tags, the cover image |
| `markdown`, `text`, `isFullText` | The article as Markdown (headings, links, lists, code blocks with language, images) and plain text. `isFullText` = false: a member-only article, you get the preview Medium shows to visitors |
| `source`, `sourceType`, `rank` | The tag, query, author or publication the row came from, and its place there |
| `scrapedAt` | Run time |

#### How it works

1. Add one or more sources: **Tags** (`artificial-intelligence`, or a medium.com/tag/... link), **Search queries**, **Authors** (`@name`, a profile link or `name.medium.com`), **Publications** (`better-programming`, a medium.com/... link or a custom domain like `javascript.plainenglish.io`) or **Article links**
2. For tags, choose the **order**: **Latest** (newest first, as deep as the tag goes), **Most read** (the ~20 most read articles of every month in your date range; all time without dates) or **Oldest**
3. Optionally set **Published after / before** (`2026-01-01` or `30 days`, `6 months`), **Minimum claps** and **Member-only** (all, free only, member-only only)
4. Set **Max articles per source** and run. Download as CSV, Excel, JSON or HTML. Three tabs: **Articles**, **Engagement**, **Text**

The article text is on by default; turn it off for faster runs when you need only the numbers.

#### Why this Actor

| | |
|---|---|
| 📚 **No 10-article limit** | Medium's RSS feeds give only the 10 latest articles. Here a tag goes back years, an author or a publication gives the whole history, a search up to ~1 000 articles |
| 🏆 **Most read of every month** | The top articles of a tag for each month of any period: what really worked in your niche in 2024, 2025 or last quarter |
| 👏 **Real engagement** | Claps, clappers, responses, reading time, word count and author followers on every row, plus claps per 1,000 followers to spot outliers |
| 📝 **Full text as Markdown** | Clean Markdown of free articles, ready for RAG, LLM training sets, summaries or newsletters; member-only articles are flagged |
| 🎯 **Filters that cost nothing** | Dates, minimum claps, free / member-only: filtered-out articles are not charged |
| 🔔 **New-article alerts** | **Only new articles** returns just what appeared since the previous run of the same source |
| 💰 **$1.99 per 1,000 articles** | Text included, no subscription |

#### Get new Medium articles every day

1. Add your tags, authors, publications or keywords and turn on **Only new articles**
2. Save as a task and add a schedule, e.g. every morning
3. The **first run** returns the latest articles as a baseline. **Every later run** returns only articles not seen before: send them to [Google Sheets](https://apify.com/s_actors/google-sheets-import-export), Slack or email with an integration

The memory is kept in your account (key-value store `medium-scraper-state`). Use a different **Monitor name** for each task.

#### Pricing

Pay per article in the results, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.001 | $0.001 | $0.001 |
| Article (one row, text included) | $0.00199 | $0.00155 | $0.00098 |

| Task | Cost |
|---|---|
| 20 latest articles of a tag | ~$0.04 |
| Most read Python articles of every month of 2025 (~230) | ~$0.46 |
| 1,000 search results for one keyword, with text | ~$2.00 |
| Daily alert of new articles of 5 authors (~3 a day) | ~$0.21 per month |

Articles left out by your filters or by **Only new articles** are not charged.

#### Ready-made tasks

Open it, change the tag, and run:

| Task | What you get |
|---|---|
| [Top Medium Articles by Tag](https://apify.com/s_actors/medium-scraper/examples/top-medium-articles-by-tag) | The most read articles of a tag for every month of the last year, with claps, responses and text |

#### FAQ

**Where does the data come from?** From medium.com itself, the same data any visitor sees, without logging in. Claps, responses and followers are Medium's own counts at the time of the run.

**Do I get the text of member-only articles?** No. Member-only (paywalled) articles give the preview Medium shows to visitors who are not members, and `isFullText` is false. All their numbers (claps, responses, reading time, words) are complete. Use **Member-only = Free articles only** when you need the full text of every row.

**How many articles can I get?** A tag: as many as it has with **Latest** (Medium tags have up to hundreds of thousands), about 20 per month with **Most read**. A search: up to ~1 000 per query (Medium's limit). An author or a publication: the whole history.

**Why does "Most read" give ~20 articles per month?** That is the list Medium keeps for each period. Set a longer date range for more months, or use **Latest** with **Minimum claps** to scan every article of the period.

**What date formats work?** `2026-01-31`, `2026-01-31T10:00:00Z`, or relative: `7 days`, `2 weeks`, `3 months`, `1 year`.

**Do I need a Medium account or an API key?** No.

#### Use with the API and AI agents

Run it via the [Apify API](https://docs.apify.com/api/v2) from Python, Node.js or any HTTP client as your Medium articles API, or connect it to Claude, ChatGPT and other AI agents through the [Apify MCP server](https://mcp.apify.com): "Find the most clapped Medium articles about AI agents from the last 3 months and summarize what they have in common."

#### Other blog & content tools

| Tool | What it does |
|---|---|
| [Substack Scraper](https://apify.com/s_actors/substack-scraper) | Substack newsletters and posts with likes, comments and full text |
| [YouTube Transcript Scraper](https://apify.com/s_actors/youtube-transcript-scraper) | Transcripts of YouTube videos and channels as text |
| [Audio & Video Transcriber](https://apify.com/s_actors/audio-video-transcriber) | Podcasts and any audio or video file to text |
| [Threads Scraper](https://apify.com/s_actors/threads-scraper) | Threads posts and profiles with likes and replies |
| [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) | Send the articles to a Google Sheet |

#### Is it legal?

The Actor reads only public pages and data that Medium shows to any visitor, without logging in, and does not get around the paywall. Articles belong to their authors: respect copyright when you reuse the text, and follow data protection rules (such as GDPR) for the author names and bios in the results.

# Actor input Schema

## `tags` (type: `array`):

Medium tags (topics) like "artificial-intelligence", "python" or "startup", or tag links (medium.com/tag/...). Sorted by "Tag articles order" below.

## `searchQueries` (type: `array`):

Keywords, like the Medium search box: "vector database", "remote work". Up to ~1 000 articles per query, most relevant first.

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

Usernames (with or without @) or profile links (medium.com/@name, name.medium.com). All articles of the author, newest first.

## `publications` (type: `array`):

Publication slugs or links: "better-programming", medium.com/swlh, or a custom domain like javascript.plainenglish.io. Newest articles first.

## `articleUrls` (type: `array`):

Links to Medium articles (any domain of Medium, medium.com/p/<id> too): one row each with stats and text.

## `tagSort` (type: `string`):

Latest: newest first, as deep as the tag goes. Most read: the ~20 most read articles of the tag for each month of the date range (all time without dates). Oldest: from the first article of the range on.

## `publishedAfter` (type: `string`):

Only articles published on or after this date: 2026-01-01, or relative: "7 days", "3 months", "1 year".

## `publishedBefore` (type: `string`):

Only articles published before this date (same formats). With a tag, the date range is read month by month, so old months come straight away.

## `minClaps` (type: `integer`):

Only articles with at least this many claps (left-out articles are free).

## `memberOnly` (type: `string`):

All, only free articles (full text available), or only member-only (paywalled) ones.

## `maxArticlesPerSource` (type: `integer`):

For each tag, query, author and publication.

## `maxArticles` (type: `integer`):

The run stops at this many articles.

## `includeContent` (type: `boolean`):

Full text of free articles as Markdown (headings, links, code, images) and plain text. Member-only articles: the preview Medium shows to visitors (isFullText = false).

## `onlyNew` (type: `boolean`):

Output only articles not seen in the previous runs of the same source (and monitor name). Schedule it daily to get new articles of a tag, author or keyword.

## `monitorName` (type: `string`):

Keeps the memory of seen articles apart for different schedules.

## `debugLog` (type: `boolean`):

Log every request retry.

## Actor input object example

```json
{
  "tags": [
    "artificial-intelligence"
  ],
  "tagSort": "latest",
  "memberOnly": "all",
  "maxArticlesPerSource": 20,
  "maxArticles": 1000,
  "includeContent": true,
  "onlyNew": false,
  "debugLog": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Every article: title, link, author, publication, date, claps, responses.

## `all` (type: `string`):

Every field, with the Markdown and plain text of each article.

# 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 = {
    "tags": [
        "artificial-intelligence"
    ],
    "maxArticlesPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/medium-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 = {
    "tags": ["artificial-intelligence"],
    "maxArticlesPerSource": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/medium-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 '{
  "tags": [
    "artificial-intelligence"
  ],
  "maxArticlesPerSource": 20
}' |
apify call s_actors/medium-scraper --silent --output-dataset

```

## MCP server setup

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