# Medium Scraper (`lagenuina_agency/medium-scraper`) Actor

Medium API alternative: scrape articles by tag, author, publication, keyword search or URL. Title, subtitle, author, date, claps, responses, reading time, tags and full text as clean Markdown for AI/RAG. Paywalled stories flagged.

- **URL**: https://apify.com/lagenuina_agency/medium-scraper.md
- **Developed by:** [Quelli di Carne Genuina](https://apify.com/lagenuina_agency) (community)
- **Categories:** News, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

A fast **Medium API** alternative. Scrape Medium articles by **tag**, **author (@username)**, **publication**, **keyword search** or **article URL** and get title, subtitle, author, publish date, **claps**, **responses**, **reading time**, tags and the **full article text as clean Markdown**, ready for AI agents, RAG pipelines and LLM datasets. Member-only stories are flagged with `isPaywalled` and return only Medium's public preview: no paywall bypass.

> Independent tool, not affiliated with or endorsed by A Medium Corporation. It reads the same public data you see on medium.com.

### What you get

One row per article (real result, shortened):

```json
{
  "id": "c2d91ecfdf77",
  "url": "https://medium.com/data-science/improving-agent-systems-ai-reasoning-c2d91ecfdf77",
  "title": "Improving Agent Systems & AI Reasoning",
  "subtitle": "DeepSeek-R1, OpenAI o1 & o3, Test-Time Compute Scaling, Model Post-Training and the Transition to Reasoning Language Models (RLMs)",
  "author": "Tula Masterman",
  "authorUsername": "tula.masterman",
  "publication": "TDS Archive",
  "publishedAt": "2025-02-02T14:32:00.159Z",
  "claps": 166,
  "responses": 4,
  "readingTimeMinutes": 8.9,
  "wordCount": 2200,
  "tags": ["aireasoning", "generative-ai-tools", "ai-agent", "llm", "editors-pick"],
  "isPaywalled": false,
  "markdown": "### DeepSeek-R1, OpenAI o1 & o3, Test-Time Compute Scaling...\n\n![Image by author](https://miro.medium.com/v2/resize:fit:1400/1*oI0lijofursOtYkoEZqtrw.png)\n\n..."
}
```

**Try it in 1 click: the prefilled example runs in seconds.** Press *Start* with the prefilled tag ("artificial-intelligence"): in our test today it returned 30 articles with full text in 4 seconds at 512 MB, for $0.24.

**Price:** $8 per 1,000 articles ($0.008 each) on every Apify plan, platform usage included, no start fee.

### Why this Medium scraper

- **More than RSS**: Medium RSS feeds stop at the latest ~10 stories and have no claps, responses or reading time. This actor reads Medium's own public data, so you get **hundreds of stories per tag, author or publication**, plus **keyword search**, engagement metrics and reading time.
- **Clean Markdown for AI and RAG**: headings, lists, links, bold, code blocks (with language) and images are preserved as Markdown; `text` gives plain text and `html` (optional) simple HTML. No navigation, cookie banners or "sign up" clutter.
- **Honest paywall handling**: member-only stories are returned with `isPaywalled: true` and only the public preview Medium shows to logged-out readers.
- **Cheaper**: 20% less per article than moving_beacon-owner1/medium-scraper ($0.008 vs $0.01) and no start fee.
- **Drop-in compatible**: accepts `users`, `publications`, `tags`, `feedUrls`, `includeHtml`, `fetchFullArticle`, `maxItemsPerFeed`, `maxItems`, `proxyConfiguration` and also returns `title`, `url`, `author`, `published`, `categories`, `text`, `word_count`, `feed`, `html`.
- **Reliable**: every request retries through a fresh proxy session; one bad source never fails the run, it is listed in the `FAILED` record and not billed. Duplicates across sources are removed.

### What you can do with it

- **AI agents and RAG**: feed your vector database or LLM with clean Markdown articles on any topic (`rag`, `llm`, `startups`...).
- **Content research and SEO**: find the most-clapped stories on a topic, what competitors publish, which tags they use.
- **Author and publication monitoring**: track new posts from writers, companies' engineering blogs (Netflix, Airbnb, Uber...) or publications.
- **Datasets**: build corpora of articles with dates, tags and engagement for analysis or fine-tuning (respect the authors' rights).

### Input

```json
{
  "tags": ["artificial-intelligence", "rag"],
  "users": ["@dhh"],
  "publications": ["towards-data-science"],
  "searchQueries": ["rag agents"],
  "articleUrls": ["https://medium.com/p/56c483d827fc"],
  "feedUrls": ["https://netflixtechblog.com"],
  "maxItemsPerFeed": 40,
  "maxItems": 5000,
  "includeContent": true,
  "includeHtml": false
}
```

| Field | What it does |
|---|---|
| `tags` | Medium tags; newest stories first. |
| `users` | Usernames with or without `@`, or profile URLs (also `name.medium.com`). |
| `publications` | Publication slugs or URLs, custom domains included. |
| `searchQueries` | Keyword search, like the search box on medium.com. |
| `articleUrls` / `startUrls` | Article URLs; any other Medium URL (profile, tag, publication, search) is recognised too. |
| `feedUrls` | Explicit RSS feeds, for example custom-domain blogs; `/feed` is added if missing. RSS lists ~10 stories. |
| `maxItemsPerFeed` | Max articles per source (default 30). |
| `maxItems` | Max articles in total (default 5000). |
| `includeContent` | Full text as `markdown` and `text` (default on). Off = metadata only. |
| `includeHtml` | Also return `html`. |
| `maxConcurrency`, `proxyConfiguration` | Parallelism (1-5) and proxy (Apify datacenter proxy by default). |

### Output

| Field | Description |
|---|---|
| `id`, `url` | Medium post id and canonical URL. |
| `title`, `subtitle` | Headline and subtitle. |
| `author`, `authorUsername`, `authorId`, `authorUrl` | Writer. |
| `publication`, `publicationSlug`, `publicationUrl` | Publication, when the story belongs to one. |
| `publishedAt`, `updatedAt` | ISO dates. |
| `claps`, `responses` | Engagement. |
| `readingTimeMinutes`, `wordCount`, `language` | As computed by Medium. |
| `tags` | Tag slugs. |
| `isPaywalled`, `contentIsPreview`, `visibility` | Member-only flag; when true, `markdown`/`text` hold only the public preview. |
| `imageUrl` | Cover image. |
| `markdown`, `text`, `html` | Body as Markdown, plain text, optional HTML. |
| `published`, `categories`, `word_count`, `feed` | Same values under the field names of moving_beacon-owner1/medium-scraper. |
| `source`, `scrapedAt` | Which input produced the row, and when. |

### Pricing

Pay per article, platform usage included. Same price on every Apify plan:

| Event | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|
| Article (one story with metadata and full public text) | $0.008 | $0.008 | $0.008 | $0.008 |
| Run start | free | free | free | free |

Examples: 1,000 articles = $8. The latest 30 stories of a tag = $0.24. Set a maximum total charge to cap spending; the actor stops cleanly when it is reached. Failed or not-found articles are not billed.

### Migrating from moving_beacon-owner1/medium-scraper

Change the actor ID to `lagenuina_agency/medium-scraper`; the input works as is.

| moving_beacon-owner1/medium-scraper | This actor | Notes |
|---|---|---|
| `users` | `users` | Same. GraphQL instead of RSS: up to `maxItemsPerFeed` stories, not only the latest ~10. |
| `publications` | `publications` | Same; custom domains also accepted. |
| `tags` | `tags` | Same; newest stories, beyond the 10 of RSS. |
| `feedUrls` | `feedUrls` | Same (RSS, ~10 latest stories). |
| `includeHtml` | `includeHtml` | Same; HTML rebuilt from the article structure. |
| `fetchFullArticle` | (not needed) | The full public text is always included. |
| `maxItemsPerFeed`, `maxItems` | same | Same meaning and defaults. |
| `proxyConfiguration` | `proxyConfiguration` | Default is Apify datacenter proxy. |
| (not available) | `searchQueries`, `articleUrls`, `includeContent` | Extra: keyword search, single articles, metadata-only mode. |

**Output:** `title`, `url`, `author`, `published`, `categories`, `text`, `word_count`, `feed` and `html` keep the same names. Extra fields: `subtitle`, `claps`, `responses`, `readingTimeMinutes`, `markdown`, `isPaywalled`, `publication`, `authorUsername`, `imageUrl` and more (see Output). `full_fetch` is not returned.

**Price per 1,000 articles** (public Apify Store prices, checked on 17 October 2026): $10 + a small start fee there, **$8** here, on every plan.

### Limits / not supported

- Member-only (paywalled) stories: only the public preview Medium shows to logged-out readers; we never log in or bypass the paywall.
- Comments (responses) are counted, not scraped. Highlights, follower counts and Medium Partner Program earnings are not returned.
- `feedUrls` and tags without an archive use RSS, which lists only the ~10 latest stories.
- Keyword search follows Medium's own ranking; the number of results depends on Medium.
- Embedded content (YouTube, Gists, tweets) is returned as a link, not as its content.

### Integrations and API

Call it from your code with the official Apify clients:

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lagenuina_agency/medium-scraper").call(run_input={"tags": ["rag"], "maxItemsPerFeed": 20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["claps"], item["url"])
```

```js
// npm i apify-client
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lagenuina_agency/medium-scraper').call({ tags: ['rag'], maxItemsPerFeed: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Ready-to-run examples (Python, JavaScript, n8n workflow): [github.com/assa83/medium-scraper-api](https://github.com/assa83/medium-scraper-api).

No-code: use the Apify app in **n8n**, **Make** or **Zapier** (action "Run Actor", pick `lagenuina_agency/medium-scraper`). Results can be pushed to Google Sheets, Slack, webhooks or any S3 bucket via Apify integrations.

### Use it from AI agents (MCP, LangChain, CrewAI)

This actor is a ready-made tool for any MCP client (Claude, ChatGPT, Cursor, custom agents) through the Apify MCP server:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com/?actors=lagenuina_agency/medium-scraper" }
  }
}
```

Ask things like *"Summarise the 10 most recent Medium articles tagged rag"*, *"What did @dhh write on Medium?"* or *"Find Medium posts about LangGraph agents and list the most clapped"*. In Python, load articles straight into LangChain with `langchain-apify` (`ApifyDatasetLoader`, mapping `markdown` to `page_content` and `url` to metadata) or give CrewAI agents the `ApifyActorsTool("lagenuina_agency/medium-scraper")`.

### More tools from Quelli di Carne Genuina

**Ad intelligence**

- [Google Ads Transparency Scraper](https://apify.com/lagenuina_agency/google-ads-transparency-scraper): every ad a brand or domain runs on Google Search, YouTube, Shopping, Maps and Play.
- [Meta Ad Library Scraper](https://apify.com/lagenuina_agency/meta-ad-library-scraper): Facebook and Instagram ads by page, keyword or Ad Library URL, with creatives and landing pages.
- [TikTok Top Ads Scraper](https://apify.com/lagenuina_agency/tiktok-top-ads-scraper): top-performing TikTok ads from the Creative Center with CTR, likes and MP4 video URLs.
- [LinkedIn Ad Library Scraper](https://apify.com/lagenuina_agency/linkedin-ad-library-scraper): B2B ads of any company from the public LinkedIn Ad Library, with targeting and impressions.

**Competitor & SEO research**

- [Similarweb Website Traffic Scraper](https://apify.com/lagenuina_agency/similarweb-scraper): monthly visits, ranks, traffic sources and top countries for any list of domains.
- [Google Trends Scraper](https://apify.com/lagenuina_agency/google-trends-scraper): interest over time, by region, related queries and Trending Now.
- [Google Play Store Scraper](https://apify.com/lagenuina_agency/google-play-scraper): app search, details, top charts and reviews from Google Play, any country.

**Travel prices**

- [Google Hotels Scraper](https://apify.com/lagenuina_agency/google-hotels-scraper): hotel prices and every booking site's rate for any city and dates.
- [Google Flights Scraper](https://apify.com/lagenuina_agency/google-flights-scraper): fares, airlines, stops, price level and price calendar for any route and date.

**Retail prices**

- [Woolworths AU Product Scraper](https://apify.com/lagenuina_agency/woolworths-scraper): Woolworths Australia grocery prices, specials, unit prices and barcodes.
- [Coles AU Product Scraper](https://apify.com/lagenuina_agency/coles-scraper): Coles Australia grocery prices, half-price specials, unit prices and barcodes.

**Content & social data**

- [YouTube Transcript Scraper](https://apify.com/lagenuina_agency/youtube-transcript-scraper): transcripts of videos, Shorts, playlists and channels as text, SRT or VTT.
- [Likee Scraper](https://apify.com/lagenuina_agency/likee-scraper): Likee videos, profiles and creator engagement analytics.

### FAQ

**Is there an official Medium API?** Medium's official API is no longer open to new integrations and never offered reading articles by tag or search. This actor gives you that public data today, with no token from Medium.

**How do I get Medium articles as Markdown for an LLM or RAG?** Run the actor with `includeContent: true` (default): every article has a `markdown` field with headings, lists, links, code blocks and images preserved.

**Can I scrape member-only / paywalled Medium articles?** No. For member-only stories you get the metadata and the public preview, with `isPaywalled: true`. We do not bypass Medium's paywall.

**How do I get more than 10 posts from a Medium RSS feed?** Put the username, publication or tag in `users`, `publications` or `tags` instead of `feedUrls` and raise `maxItemsPerFeed`.

**Can I get claps and reading time?** Yes: `claps`, `responses`, `readingTimeMinutes` and `wordCount` are in every row.

**Does it work with custom domains (e.g. netflixtechblog.com)?** Yes, as a publication URL, article URL or feed URL.

**Is scraping Medium legal?** The actor reads publicly available pages and data. Articles are copyrighted by their authors: you are responsible for how you use the content; check your local laws and Medium's terms.

**Something broke?** Open an issue on the Issues tab: we answer within 24 hours.

# Actor input Schema

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

Medium tags (e.g. 'artificial-intelligence', 'rag', 'programming'). Newest stories with each tag.

## `users` (type: `array`):

Medium usernames, with or without @ (e.g. '@dhh'), or profile URLs. Latest stories of each author.

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

Publication slugs (e.g. 'towards-data-science', 'better-programming') or publication URLs, custom domains included.

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

Search Medium stories by keyword, like the search box on medium.com (e.g. 'rag agents').

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

Specific Medium article URLs (medium.com, \*.medium.com or custom-domain publications). Any other Medium URL (profile, tag, publication, search) also works.

## `feedUrls` (type: `array`):

Explicit Medium RSS feed URLs, including custom-domain publications. '/feed' is added if missing.

## `maxItemsPerFeed` (type: `integer`):

Maximum articles from each tag, author, publication, search or feed. Tags, authors, publications and search go far beyond the 10 items of RSS (RSS feeds stay at ~10).

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

Hard cap on articles saved across all sources.

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

Article body as clean Markdown and plain text, ready for LLMs and RAG. For member-only stories only Medium's public preview is returned (flagged with isPaywalled).

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

Also return the article body as simple HTML.

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

Parallel requests (each fetches up to 10 articles).

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

Apify Proxy (datacenter) is used by default and is enough in most cases.

## Actor input object example

```json
{
  "tags": [
    "artificial-intelligence"
  ],
  "maxItemsPerFeed": 30,
  "maxItems": 5000,
  "includeContent": true,
  "includeHtml": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("lagenuina_agency/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"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lagenuina_agency/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"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lagenuina_agency/medium-scraper --silent --output-dataset

```

## MCP server setup

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