# Medium Scraper - Articles, Claps, Comments, Authors & Full Text (`topapi/medium-scraper`) Actor

Medium stories by tag (whole archive or Top lists), search, writer, publication, list or link: claps, clappers, responses, reading time, tags, language, member-only flag, writer and publication stats; full text, responses, writer and tag rows. Monitor mode. $0.18 per 1,000 stories, no start fee.

- **URL**: https://apify.com/topapi/medium-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** News, Social media, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.18 / 1,000 stories

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

### What does Medium Scraper do?

**Medium Scraper** extracts Medium stories from [medium.com](https://medium.com) by tag, keyword search, writer, publication, reading list or link, and turns them into structured rows: one row per story with its title, link, dates, reading time, word count, **claps**, **distinct clappers**, **responses**, tags, language, member-only flag, and the stats of its writer and publication. Switch on the full text (plain text, Markdown, HTML), responses and replies, or a profile row per writer, publication, tag and list. Built for content marketers, newsletter curators, AI and RAG teams, and anyone researching writers, topics and engagement on Medium without copying pages by hand.

Medium Scraper · Medium API alternative · Medium articles scraper · Medium tag scraper · Medium author scraper · Medium comments scraper

- **Every story of a tag, not ten:** the tag archive is read newest first back to the tag's first story (or oldest first, or Medium's most-read ranking month by month), plus Medium's own Hot, New, Top week / month / year / all-time and Recommended lists
- **Engagement on every row:** claps, distinct clappers, claps per clapper, responses, claps per 1,000 writer followers, and (optional) this story's claps against the writer's own median
- **Full text at no extra charge:** free stories come complete as text, Markdown (code blocks keep their language) and HTML; member-only stories give the public preview, flagged `contentIsPreview`
- **Search past Medium's 1,000-result limit:** a big search is repeated year by year without duplicates (2,000 stories from one query in a measured run)
- **No login, cookies or Medium API key:** it reads what Medium shows any signed-out visitor
- **Pay only for delivered rows:** no start fee; duplicates, filtered stories and stories a monitor already delivered cost nothing
- **Export anywhere:** JSON, CSV, Excel, XML, RSS; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Slack
- **Works with AI agents:** call it through the Apify API or the MCP server

### What data can you get from Medium?

<table>
<tr><td>📰 Title and subtitle</td><td>🔗 Link and canonical link (`canonicalUrl`)</td><td>📅 Published and updated dates</td></tr>
<tr><td>👏 Claps (`clapCount`)</td><td>🙋 Distinct clappers (`voterCount`)</td><td>💬 Responses (`responsesCount`)</td></tr>
<tr><td>⏱️ Reading time and word count</td><td>🏷️ Tags, tag names, Medium topics</td><td>🔒 Member-only flag (`isLocked`)</td></tr>
<tr><td>🌐 Language</td><td>🖼️ Preview image, its alt text and size</td><td>📜 License</td></tr>
<tr><td>✍️ Writer: name, username, bio, avatar</td><td>👥 Writer followers and following</td><td>⭐ Member, Partner Program, book author, X handle</td></tr>
<tr><td>🏢 Publication: name, link, own domain, followers</td><td>📈 Claps per 1,000 followers, claps per clapper</td><td>🆕 Fresh flag (under 48 hours)</td></tr>
<tr><td>📝 Full text: text, Markdown, HTML</td><td>🧭 Table of contents, images, outbound links</td><td>💻 Code-block and paragraph counts</td></tr>
<tr><td>💬 Responses and replies as rows</td><td>🧑 Writer rows with posting activity and medians</td><td>📚 Publication, tag and list rows</td></tr>
</table>

On a 1,000-story run of the newest `artificial-intelligence` stories, every row had a title, link, dates, reading time, word count, claps, clappers, responses, language and tags; 98% had a subtitle, 90% a preview image, 86% Medium topics (Medium assigns them a few days after publication), 84% a writer bio, 25% a publication and 17% a writer X handle. 31% of those stories were member-only.

### How to scrape Medium with Medium Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up): $5 of monthly credit, no card needed.
2. Open [Medium Scraper](https://apify.com/TopApi/medium-scraper) and click **Try for free**.
3. Enter **Tags**, **Search terms**, **Writers**, **Publications**, or paste **Medium links**, and set **Max stories**.
4. Switch on **Include full text**, **Include responses** or the profile rows if you need them.
5. Click **Start**. Rows stream into the dataset as each page is read.
6. Open the **Storage** tab and **Export** as JSON, CSV or Excel, or let a schedule run it for you.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to scrape** | | Any mix; at least one source (an empty input reads 25 newest `programming` stories as a sample) |
| `tags` | List | Tag slugs, names or links: `artificial-intelligence`, `Machine Learning`, `https://medium.com/tag/python` |
| `tagSort` | Select | `newest` (whole archive, default), `oldest`, `most-read`, `hot`, `new`, `top-week`, `top-month`, `top-year`, `top-all-time`, `recommended`, `all-top` (all ranked lists merged) |
| `searchQueries` | List | Medium search, one query per line |
| `searchType` | Select | `posts` (default), `people`, `publications`, `tags`, `lists` |
| `authors` | List | `@username`, `username`, `https://medium.com/@ev`, `https://name.medium.com` |
| `publications` | List | `better-programming`, `https://medium.com/swlh`, `levelup.gitconnected.com` |
| `startUrls` | List | Any Medium link: story (also on a writer subdomain or a publication domain), tag page (`/tag/python/top/week`), profile, publication, search page, list, RSS feed link; story IDs work too |
| `urlsFromFile` | Text | Link of a .txt / .csv file or a shared Google Sheet listing Medium links, story IDs or @handles |
| **🎯 Filters** (before any charge) | | |
| `publishedAfter` / `publishedBefore` | Text | `2025-01-01`, an ISO time, or relative: `30 days`, `6 months`, `24 hours` |
| `minClaps` / `minResponses` | Integer | Leave out stories under these counts. Default `0` |
| `language` | Text | ISO codes, comma-separated: `en` or `en, es, pt` |
| `memberOnly` | Select | `all` (default), `free`, `memberOnly` |
| `keywords` / `excludeKeywords` | List | Words a story's title, subtitle, tags (or text) must / must not contain |
| **➕ Extra data** | | |
| `includeContent` | Boolean | Full text as plain text and Markdown, images, links, table of contents. No extra charge |
| `includeHtml` | Boolean | The body as HTML too. No extra charge |
| `includeImagesInMarkdown` | Boolean | Keep images in the Markdown. Default `true` |
| `includeResponses` | Boolean | Responses of every delivered story as rows, charged as **response** |
| `maxResponsesPerPost` | Integer | Default `20`; `0` = all |
| `includeReplies` | Boolean | Follow the reply threads too (depth 2, 3 ...) |
| `includeProfiles` | Boolean | A profile row per tag, writer, publication and list you listed, charged as **profile** |
| `includeArticles` | Boolean | Off = only those profile rows. Default `true` |
| `includeAuthors` / `includePublications` | Boolean | A profile row per writer / publication of the delivered stories |
| `maxProfiles` | Integer | Cap on those extra profile rows. Default `100` |
| `compareWithAuthor` | Boolean | Adds `authorMedianClaps` and `vsAuthorMedian` to every story. No extra charge |
| **🔁 Monitoring** | | |
| `monitorMode` | Boolean | Return only stories not delivered by earlier runs of the same setup |
| `monitorKey` / `resetMonitor` | Text / Boolean | Name a shared memory; start it over |
| **📦 Output** | | |
| `maxItems` | Integer | Default `100`; `0` = no limit |
| `maxPostsPerSource` | Integer | Cap per tag, writer, publication, search or list. Default `0` (none) |
| `dedupe` | Boolean | A story found by several sources is delivered once. Default `true` |
| **⚙️ Advanced** | | |
| `maxConcurrency`, `requestTimeoutSecs`, `proxyConfiguration` | | Sources in parallel (default 8), request timeout (default 30 s), an optional proxy (none needed) |

Inputs named like other Medium actors' (`articleUrls`, `postUrls`, `pageAndProfileUrls`, `searchTerms`, `authorProfiles`, `maxResults`, `maxArticles`, `limit`, `tagFeedMode`, `includeText`, `includeFullText`, `onlyNewPosts`, `skipMemberOnly`, `publishedWithinDays` ...) are accepted too, so an API caller can switch without rewriting its input.

#### Input JSON

```json
{
  "tags": ["artificial-intelligence", "startup"],
  "tagSort": "newest",
  "publishedAfter": "7 days",
  "minClaps": 10,
  "includeContent": true,
  "maxPostsPerSource": 200,
  "maxItems": 400
}
```

#### Pick the tag list before anything else

`newest` walks a tag's complete archive (the `programming` tag holds 463,000 stories), so a big **Max stories** keeps going back in time. The ranked lists hold about 100 stories each (Recommended 300+). **Do:** `"tagSort": "top-month"` for what readers clapped this month · **Don't:** expect 1,000 rows from one ranked list (it ends at ~100; use `all-top` or several tags).

#### Use a date window instead of reading everything

`publishedBefore` starts a tag, writer or publication at that date, and `publishedAfter` stops a newest-first tag or writer there, so `{"tags": ["javascript"], "publishedAfter": "2021-03-01", "publishedBefore": "2021-03-31"}` reads only March 2021. With `tagSort: "most-read"` a window is read month by month (about 20 stories a month).

#### Member-only stories are previews

Every field of a member-only story is filled except the body, which is the public preview a signed-out reader sees (`contentIsPreview: true`; `wordCount` is still the full story's). Set `memberOnly: "free"` when you need complete text.

### ⬆️ Output

Every story becomes one item with `type: "post"`; responses are `type: "response"`, profile rows `author`, `publication`, `tag` or `list`. The Dataset tab has a view for each (Stories, Full text, Responses, Writers, Publications, Tags and lists). A real story row from a 1,000-row run (abbreviated):

```json
{
  "type": "post",
  "id": "8a855a04c955",
  "url": "https://briefs.aiadvances.org/how-to-run-microsofts-4b-computer-use-agent-without-giving-it-your-machine-8a855a04c955",
  "title": "How to Run Microsoft’s 4B Computer-Use Agent Without Giving It Your Machine",
  "publishedAt": "2026-11-06T18:20:11.730Z",
  "readingTimeMinutes": 8.85,
  "wordCount": 2199,
  "clapCount": 100,
  "voterCount": 2,
  "responsesCount": 0,
  "isLocked": true,
  "language": "en",
  "tags": ["programming", "artificial-intelligence", "machine-learning", "cybersecurity", "ai-agent"],
  "authorName": "MohamedAbdelmenem",
  "authorFollowers": 3216,
  "authorIsPartnerProgram": true,
  "publicationName": "AI Advances Briefs",
  "publicationDomain": "briefs.aiadvances.org",
  "clapsPer1kFollowers": 31.09,
  "source": "tag:artificial-intelligence",
  "rank": 66
}
```

A response row:

```json
{
  "type": "response",
  "id": "fc4d7dc89d5b",
  "text": "The “none” affiliation includes Jitendra Malik and Michael Jordan xD",
  "publishedAt": "2017-05-26T00:09:41.924Z",
  "clapCount": 0,
  "repliesCount": 0,
  "depth": 1,
  "rootPostUrl": "https://karpathy.medium.com/icml-accepted-papers-institution-stats-bad8d2943f5d",
  "authorName": "David Krueger",
  "authorFollowers": 2
}
```

A writer row (with `includeProfiles`, abbreviated):

```json
{
  "type": "author",
  "name": "Andrej Karpathy",
  "username": "karpathy",
  "followerCount": 62184,
  "followingCount": 183,
  "twitter": "karpathy",
  "customDomain": "karpathy.medium.com",
  "lastPostDate": "2017-11-11T22:18:53.751Z",
  "medianClaps": 1800.5,
  "medianResponses": 14,
  "topPostTitle": "Software 2.0",
  "topPostClaps": 61073,
  "topTags": ["machine-learning", "artificial-intelligence", "deep-learning", "programming", "software-development"]
}
```

#### Fields

| Field | What it is | Fill (1,000-story run) |
|---|---|---|
| `title`, `url`, `publishedAt`, `updatedAt` | Story title, link, first and latest publication | 100% |
| `readingTimeMinutes`, `wordCount` | Medium's reading time and word count | 100% |
| `clapCount`, `voterCount`, `responsesCount` | Claps, distinct clappers, responses | 100% (31% had at least one clap) |
| `clapsPerVoter`, `clapsPer1kFollowers` | Derived engagement (null without clappers / followers) | 31% / 85% |
| `isLocked`, `visibility`, `language`, `license` | Member-only flag, visibility, detected language, license | 100% |
| `tags`, `tagNames`, `topics` | Tags and Medium topics | 100% / 100% / 86% |
| `subtitle`, `previewImageUrl` | Subtitle, preview image | 98% / 90% |
| `authorName`, `authorUsername`, `authorFollowers`, `authorFollowing` | Writer | 100% |
| `authorBio`, `authorTwitter` | Writer bio and X handle | 84% / 17% |
| `authorIsMember`, `authorIsPartnerProgram`, `authorIsBookAuthor` | Writer badges | 100% |
| `publicationName`, `publicationUrl`, `publicationFollowers` | Publication (stories outside one have none) | 25% |
| `contentText`, `contentMarkdown`, `contentHtml`, `tableOfContents` | Body (with full text on) | 100% of stories (60% of them member-only previews in two Top-list runs) |
| `source`, `sourceType`, `sourceInput`, `rank` | Where the row came from and its position there | 100% |

The dataset schema documents all 118 fields of all six row types.

### How can I use Medium data?

- 🎯 **Content marketers:** pull the Top-month stories of your topics with claps and responses to see which angles, titles and lengths work
- 📨 **Newsletter curators:** schedule `publishedAfter: "1 day"` on a few tags and get each day's new stories with their text
- 🤝 **Creator and outreach teams:** search people for a topic and get writer rows with followers, bio, X and Mastodon handles, Partner Program status and posting activity
- 🤖 **AI and RAG teams:** collect clean Markdown with code blocks and their language, tags and canonical links; keep `memberOnly: "free"` for complete texts
- 🏢 **Competitor and blog monitoring:** watch a publication or an engineering blog on its own domain with monitor mode and receive only the new stories
- 📈 **Analysts:** measure a topic's output and engagement over time from the tag archive and its date windows

### How much does it cost to scrape Medium?

Medium Scraper is pay-per-event, with no start fee:

| Row | Price |
|---|---:|
| Story (`post`) | **$0.18 per 1,000** |
| Response or reply (`response`) | $1.30 per 1,000 |
| Writer, publication, tag or list row (`profile`) | $1.30 per 1,000 |

| Stories | Cost |
|---:|---:|
| 10 | $0.0018 |
| 100 | $0.018 |
| 1,000 | $0.18 |
| 10,000 | $1.80 |

Full text, HTML, the writer comparison and the activity metrics cost nothing extra. Duplicates, filtered stories and stories a monitor delivered before are never charged. Apify platform usage is included. Measured on the default 256 MB: 1,000 stories in 51-52 s, 5,000 in 258-300 s, 2,000 search results in 48 s.

### Run it on a schedule

- **Schedules:** save your input as a task, open **Schedules** and run it hourly or daily. With `monitorMode: true` each run returns only stories that earlier runs did not deliver; newest-first tags and writers stop reading at the newest story already delivered, and a poll that finds nothing writes nothing and charges nothing.
- **Example:** `{"tags": ["product-management"], "authors": ["@lenny"], "monitorMode": true, "monitorKey": "pm-daily", "includeContent": true}` on a daily schedule.
- **Webhooks:** fire a URL when a run finishes and push the rows to your CRM, Slack or a sheet.
- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable, Slack through [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client`; code is on the [API tab](https://apify.com/TopApi/medium-scraper/api/python) and in the [Apify API reference](https://docs.apify.com/api/v2).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/TopApi/medium-scraper/api/mcp) and ask for Medium stories in plain language.

### More scrapers from TopApi

<table>
<tr>
<td>📨 <a href="https://apify.com/TopApi/substack-scraper">Substack Scraper</a></td>
<td>📰 <a href="https://apify.com/TopApi/wechat-articles-scraper">WeChat Articles Scraper</a></td>
<td>📄 <a href="https://apify.com/TopApi/website-content-crawler">Website Content Crawler</a></td>
</tr>
<tr>
<td>🐦 <a href="https://apify.com/TopApi/x-profile-scraper">X Profile Scraper</a></td>
<td>🦋 <a href="https://apify.com/TopApi/bluesky-scraper">Bluesky Scraper</a></td>
<td>🧭 <a href="https://apify.com/TopApi">All TopApi actors</a></td>
</tr>
</table>

### Limits & empty runs

- **Ranked lists are short:** Hot, New and each Top list end at about 100 stories, Recommended at about 300, Most read at about 20 a month; the newest-first archive has no such limit.
- **Search:** Medium answers up to 1,000 results per query; more are read year by year (newest year first), so a search for more than 1,000 is ordered by year, then by relevance.
- **Publications** list stories in the order they were added to the publication, which is close to, but not always, their publication order.
- **Member-only bodies** are the public preview (`contentIsPreview: true`).
- **Activity metrics** (posting frequency, medians, top story) are on the profile rows of writers and publications you list; rows from searches or found writers carry the profile fields only.
- **Speed:** each source pages one request after another (about 20 stories a second on one tag); several sources run in parallel.
- **Empty dataset:** the status message names the cause: a tag, writer, publication, story or list that does not exist; filters that removed every story read (with the count per filter); or a monitor poll with nothing new. Nothing is charged.
- **Not available:** reading counts and earnings (only the writer sees them), private and draft stories, the full body of member-only stories.

### FAQ

#### How many stories can Medium Scraper collect in one run?

As many as you set in **Max stories**. A tag's newest-first archive goes back to its first story (5,000 stories in 258-300 s in our runs); ranked lists end at about 100 each; a search goes past 1,000 year by year. Use several tags or writers in one run for more.

#### Can I get the full text of Medium articles?

Yes. Turn on **Include full text**: free stories come complete as text and Markdown (and HTML with **Include HTML**). Member-only stories give the public preview, flagged `contentIsPreview`.

#### Can Medium Scraper get comments (responses)?

Yes. **Include responses** adds each delivered story's responses as rows with text, writer, claps and reply count; **Include replies** follows the threads.

#### Can I scrape a Medium writer's or publication's whole history?

Yes. List them under **Writers** or **Publications** (or paste their links). They are read newest first back to their first story; `publishedBefore` starts at an older date.

#### Can I run Medium Scraper on a schedule to get new stories only?

Yes. Turn on **Only new stories since the last run** and add a schedule. Each poll delivers and charges only stories no earlier poll delivered; an empty poll charges nothing.

#### Does Medium Scraper find writers and publications?

Yes. Set **Search for** to People, Publications, Tags or Lists, or turn on the profile rows to get one row per writer and publication you list or find.

#### Can I integrate Medium Scraper with other apps?

Yes: Make, Zapier, n8n, Google Sheets, Slack and more through [Apify integrations](https://docs.apify.com/integrations), or [webhooks](https://docs.apify.com/integrations/webhooks) when a run finishes.

#### Can I use Medium Scraper with the Apify API or MCP?

Yes. Use `apify-client` for [Node.js](https://apify.com/TopApi/medium-scraper/api/javascript) or [Python](https://apify.com/TopApi/medium-scraper/api/python), or the [MCP tab](https://apify.com/TopApi/medium-scraper/api/mcp) for Claude, Cursor and other MCP clients.

#### Do I need a Medium account, cookies or an API key?

No. Medium Scraper reads only what Medium shows a signed-out visitor.

#### Why did my run return no results?

The status message says why: the tag, writer, publication, story or list does not exist (check the spelling or link), the filters removed every story read (it lists how many each filter removed), or a monitor poll found nothing new.

#### How is Medium Scraper different from other Medium scrapers?

It reads whole tag archives and every ranked list rather than the ten stories of an RSS feed, carries distinct clappers and responses on every row, searches past the 1,000-result limit, adds writer medians and claps per follower, and costs $0.18 per 1,000 stories.

#### Your feedback

Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/TopApi/medium-scraper/issues/open).

# Actor input Schema

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

Medium tags, one per line, as a slug, a name or a link: artificial-intelligence, Machine Learning, https://medium.com/tag/python. Each tag is read the way Tag stories says (default: newest first through the tag's whole archive).

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

Which stories of each tag. Newest first walks the tag's complete archive back in time (thousands of stories). Oldest first starts at the tag's first story. Most read is Medium's most-read ranking (about 20 a month when a date window is set, otherwise all time). Hot, New and Top week / month / year / all time are Medium's own ranked lists (about 100 each); Recommended is the tag page's recommended feed (300+). All ranked lists merges Hot, the four Top lists and Recommended without duplicates.

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

Medium search, one query per line, e.g. rust async, product-led growth. Search for picks stories, people, publications, tags or lists. Medium answers up to 1,000 stories per query; when more are asked, the query is repeated year by year (newest year first) without duplicates.

## `searchType` (type: `string`):

What the search terms look for. Stories come back as story rows; people, publications, tags and lists come back as profile rows (followers, bio, description, post count, item count ...).

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

Writers as @username, username or profile link (https://medium.com/@ev, https://name.medium.com). Returns every story the writer published, newest first.

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

Publications as slug, link or own domain: better-programming, https://medium.com/swlh, levelup.gitconnected.com. Returns the publication's stories, newest first.

## `startUrls` (type: `array`):

Any Medium link, detected automatically: a story (also on a writer subdomain or a publication's own domain), a tag page (/tag/python, /tag/python/top/week), a profile, a publication, a search page (medium.com/search?q=...), a list (/@user/list/name-<id>) or an RSS feed link (/feed/@user, /feed/tag/x). Story IDs (the 12 characters at the end of a story link) work too.

## `urlsFromFile` (type: `string`):

Optional: the link of a .txt or .csv file (or a Google Sheet shared as 'anyone with the link') listing Medium links or story IDs, one per line or cell.

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

Only stories published on or after this date: 2025-01-01, an ISO time, or relative like 30 days, 6 months, 24 hours. Newest-first tags and writers stop reading at this date, so a daily run reads only what is new.

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

Only stories published on or before this date (same formats). Tags, writers and publications start reading at this date, so a past date range costs no reading of newer stories.

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

Leave out stories with fewer claps. 0 = keep all.

## `minResponses` (type: `integer`):

Leave out stories with fewer responses (comments). 0 = keep all.

## `language` (type: `string`):

Keep only stories in these languages (Medium's detected language, ISO codes, comma-separated): en or en, es, pt. Empty = all.

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

Member-only stories are behind Medium's paywall: their rows carry every field, and the full-text fields hold the public preview any signed-out reader sees. Free only keeps stories whose complete text is public.

## `keywords` (type: `array`):

Keep stories whose title, subtitle, tags (or text, with full text on) contain at least one of these words or phrases (case-insensitive).

## `excludeKeywords` (type: `array`):

Leave out stories whose title, subtitle, tags (or text, with full text on) contain any of these.

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

Add the story body as plain text and Markdown (headings, lists, quotes, code blocks with their language, links, images), its image links, outbound links, code-block and paragraph counts and a table of contents. Free stories come complete; member-only stories give the public preview (contentIsPreview = true). No extra charge: the text rides along with each page of stories.

## `includeHtml` (type: `boolean`):

Also add the body as HTML (contentHtml), e.g. to republish formatting in your own reader. No extra charge.

## `includeImagesInMarkdown` (type: `boolean`):

Keep the story's images in contentMarkdown. Off = text only.

## `includeResponses` (type: `boolean`):

Add the responses of every delivered story as rows (type = response) with full text, writer, claps, clappers and reply count. Charged per response row.

## `maxResponsesPerPost` (type: `integer`):

Responses (and replies) per story, in Medium's order. 0 = all.

## `includeReplies` (type: `boolean`):

Also follow the reply threads under each response (depth 2, 3 ...), within Max responses per story.

## `includeProfiles` (type: `boolean`):

One extra row for every tag (story count, followers, related tags), writer (followers, following, bio, membership, Partner Program, books, X and Mastodon handles, posting activity, median claps and responses, top story) and publication (followers, description, editors, activity) you list, and each list link. Charged as a profile row.

## `includeArticles` (type: `boolean`):

Off = only the profile rows of the tags, writers, publications and lists you listed (needs the profile switch above).

## `includeAuthors` (type: `boolean`):

Also one row per writer of the delivered stories (name, bio, followers, following, avatar, membership, Partner Program, X handle). Charged as a profile row, capped by Max profile rows.

## `includePublications` (type: `boolean`):

Also one row per publication of the delivered stories (followers, description, logo, domain, editors, creator). Charged as a profile row, capped by Max profile rows.

## `maxProfiles` (type: `integer`):

Cap on the extra profile rows above (listed sources plus found writers and publications). 0 = no cap.

## `compareWithAuthor` (type: `boolean`):

Adds authorMedianClaps (median claps of the writer's latest 25 stories older than 48 hours) and vsAuthorMedian (this story's claps divided by it: 4.2 = four times the writer's usual). One extra request per distinct writer; no extra charge.

## `monitorMode` (type: `boolean`):

Remember what this setup delivered and return (and charge) only stories that were not delivered before. Newest-first tags and writers stop reading at the newest story already delivered, so an empty poll costs almost nothing. Pair with a schedule.

## `monitorKey` (type: `string`):

Runs with the same name share one memory (letters, digits, dashes). Default: derived from the sources and filters, so each different input has its own memory.

## `resetMonitor` (type: `boolean`):

Forget what this monitor delivered before; this run delivers everything again and becomes the new baseline.

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

Stop after this many story rows in total (or rows of a people / publication / tag / list search). Responses and add-on profile rows have their own caps. 0 = no limit.

## `maxPostsPerSource` (type: `integer`):

Cap for each single source, so one big source cannot use up the whole run. 0 = no per-source cap.

## `dedupe` (type: `boolean`):

A story found by several tags, searches or writers is delivered (and charged) once.

## `maxConcurrency` (type: `integer`):

How many sources are read at the same time (each source pages one request after another).

## `requestTimeoutSecs` (type: `integer`):

Timeout of each request to Medium.

## `proxyConfiguration` (type: `object`):

Leave empty: the actor talks to Medium directly and moves to Apify datacenter, then residential proxy by itself only if Medium refuses. Pick a proxy group or your own proxy URLs to send every request through them first.

## Actor input object example

```json
{
  "tags": [
    "programming"
  ],
  "tagSort": "newest",
  "searchType": "posts",
  "minClaps": 0,
  "minResponses": 0,
  "memberOnly": "all",
  "includeContent": false,
  "includeHtml": false,
  "includeImagesInMarkdown": true,
  "includeResponses": false,
  "maxResponsesPerPost": 20,
  "includeReplies": false,
  "includeProfiles": false,
  "includeArticles": true,
  "includeAuthors": false,
  "includePublications": false,
  "maxProfiles": 100,
  "compareWithAuthor": false,
  "monitorMode": false,
  "resetMonitor": false,
  "maxItems": 20,
  "maxPostsPerSource": 0,
  "dedupe": true,
  "maxConcurrency": 8,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

One item per story, response, writer, publication, tag or list (type).

## `summary` (type: `string`):

Per-source counts, inputs that matched nothing, what each filter removed, monitor counts, the egress used. Written for Console runs, runs over 500 rows and runs with a refused request (other runs log it).

# 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": [
        "programming"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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": ["programming"],
    "maxItems": 20,
}

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

```

## MCP server setup

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