Pricing

from $2.80 / 1,000 post returneds

Try for free

Go to Apify Store

Medium Scraper - Posts by Author, Tag & New-Post Monitor

Try for free

Latest Medium posts by author, publication or tag from the public RSS feeds: title, author, date, URL, tags, summary and text length. Turn monitoring on and later runs return only the posts that are new since the last run.

Pricing

from $2.80 / 1,000 post returneds

Rating

0.0

(0)

Developer

NeverEmpty

Actor stats

Bookmarked

Total users

Monthly active users

12 days ago

Last modified

Categories

Social media

News

You can access the Medium Scraper - Posts by Author, Tag & New-Post Monitor programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "o2GTdxPiUiIpkTDO2"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/neverempty~medium-posts-monitor/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-neverempty-medium-posts-monitor",
        "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/neverempty~medium-posts-monitor/runs": {
      "post": {
        "operationId": "runs-sync-neverempty-medium-posts-monitor",
        "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/neverempty~medium-posts-monitor/run-sync": {
      "post": {
        "operationId": "run-sync-neverempty-medium-posts-monitor",
        "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",
        "properties": {
          "authors": {
            "title": "Medium authors",
            "type": "array",
            "description": "Medium usernames, one per line: @ev, ev, or a profile link (https://medium.com/@ev). For each one the Actor reads the author's public RSS feed (medium.com/feed/@name), which holds the author's latest 10 posts. A name Medium does not know comes back as a \"no-such-source\" row that is not charged.",
            "items": {
              "type": "string"
            }
          },
          "publications": {
            "title": "Medium publications",
            "type": "array",
            "description": "Publications, one per line: the name as in medium.com/<name> (better-programming), a link to the publication, or the publication's own domain (https://netflixtechblog.com). The Actor reads the publication's public RSS feed, which holds its latest 10 posts. A site that is not on Medium comes back as a \"not-a-medium-feed\" row that is not charged.",
            "items": {
              "type": "string"
            }
          },
          "tags": {
            "title": "Medium tags",
            "type": "array",
            "description": "Tags, one per line: programming, machine learning (spaces become hyphens), or a tag link (https://medium.com/tag/startup). The Actor reads the tag's public RSS feed: the 10 most recently published posts with that tag. Tag feeds carry a short summary of each post, not its text. Medium answers with an empty feed for a tag that does not exist, so a misspelled tag comes back as a \"no-posts\" row that is not charged.",
            "items": {
              "type": "string"
            }
          },
          "maxPostsPerSource": {
            "title": "Maximum posts per author, publication or tag",
            "minimum": 1,
            "maximum": 100,
            "type": "integer",
            "description": "Newest posts first. A Medium feed holds at most 10 posts, so 10 returns everything the feed has. In monitoring mode this limits only the first run for a source (how many of its newest posts are returned and remembered); on later runs every new post is returned.",
            "default": 10
          },
          "postedAfter": {
            "title": "Only posts published on or after",
            "type": "string",
            "description": "Optional date (YYYY-MM-DD, UTC). Posts published before it are not returned."
          },
          "includeContent": {
            "title": "Post text",
            "enum": [
              "none",
              "text",
              "html"
            ],
            "type": "string",
            "description": "Many author and publication feeds carry the full text of a post; tag feeds and some posts carry only a short summary. Every row says whether the text is in the feed (contentInFeed) and how long it is (contentLength, wordCount). Choose text or HTML to also get the text itself when the feed has it. The Actor never opens the post page, so a post whose text is not in the feed has no text here.",
            "default": "none"
          },
          "monitoringMode": {
            "title": "Monitoring mode: return only new posts",
            "type": "boolean",
            "description": "Off = return the latest posts of every author, publication and tag you listed, charged per post row. On = the posts returned for each source are remembered, and later runs return only posts that were not there before. The first monitoring run for a source returns its latest posts once (the starting point). On a later run, a source with new posts is charged per new post row (post-returned); a source with no new post is charged one small check (source-checked) and returns no row. A feed holds only the latest 10 posts: schedule runs often enough that a source does not publish more than 10 posts between two runs (busy tags publish 10 posts within minutes).",
            "default": false
          },
          "resetMonitoringState": {
            "title": "Forget the remembered posts and start over",
            "type": "boolean",
            "description": "Clears everything remembered for this Actor on your account before this run reads anything, so this run (with monitoring on) returns the latest posts of each source once again and charges for them. Use it for one run and turn it off again: left on in a schedule, every run returns and charges the same posts. This affects all your monitoring runs, because sources are remembered one by one rather than per list.",
            "default": false
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Medium Scraper - Posts by Author, Publication & Tag OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Medium Scraper - Posts by Author, Tag & New-Post Monitor from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Medium Scraper - Posts by Author, Tag & New-Post Monitor API in Python

Medium Scraper - Posts by Author, Tag & New-Post Monitor API in JavaScript

Medium Scraper - Posts by Author, Tag & New-Post Monitor API through CLI

Medium Scraper - Posts by Author, Tag & New-Post Monitor API

Medium Scraper — Articles, Full Text, Authors, Claps & Comments

logiover/medium-scraper

Scrape Medium by tag, search, author, publication or URL: posts with claps, responses, reading time, tags, author and publication stats, plus optional full article text as Markdown and comments. Whole tag archives, thousands of posts per run, no login. Not affiliated with Medium.

Logiover

Medium Articles Scraper

datacach/medium-scraper

Extract Medium articles by keyword at scale — no account needed. Returns title, author, publication, clap count, reading time, tags, and direct URLs as structured JSON.

DataCach

Medium User Posts Scraper

easyapi/medium-user-posts-scraper

Extract detailed post data from Medium user profiles. Get comprehensive information about articles, including engagement metrics, publication details, and content status. Perfect for content analysis, research, and tracking Medium writers' performance. 🔍📊

EasyApi

Medium Scraper

romy/medium-scraper

Medium Scraper is an advanced scraper that allows you to access and extract content from Medium, even for articles that usually require a subscription. This scraper uses bypass techniques to circumvent the "Subscribe now for uninterrupted access" restriction imposed by Medium.

Romy

Bluesky Post Scraper

bytepulselabs/bluesky-post-scraper

Scrape all Bluesky posts. Add one or more Bluesky handles and extract post content, embeds, and engagement metrics. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

BytePulse Labs

5.0

(8)

TikTok Live Status Scraper & Monitor - Go-Live Alerts, Viewers

neverempty/tiktok-live-status-monitor

Check whether TikTok accounts are live right now: viewer count, total enters, stream title, start time, playback URLs and follower count. Turn monitoring on and a run returns an account only when it goes live or ends a stream, for a small fee per account checked.

NeverEmpty

TikTok Comments Scraper & Monitor - Replies, Likes, New Only

neverempty/tiktok-comments-scraper

For brand monitoring, community management and sentiment research: comments of TikTok videos as rows with text, author, likes, reply count, time posted and whether the creator pinned or liked them, with optional replies. Monitoring returns only comments posted since the last run. Unofficial.

NeverEmpty

YouTube Community Posts Scraper & New Post Monitor

neverempty/youtube-community-posts-scraper

Posts from any YouTube channel's Posts (Community) tab: text, full links, images, polls with vote totals, quizzes with correct answers, shared videos, likes and comments. Monitoring mode returns only posts that are new since the last run, and can track poll vote counts.

NeverEmpty

Medium Scraper

ivanvs/medium-scraper

Scrape data such as authors, titles, applause, responses and publication dates from the Medium blogging platform. Download listings data in JSON, XML, Excel, and other versatile

Gen First

327

4.0

(1)

Medium Profile Scraper

agentx/medium-profile-scraper

Medium profile scraper that returns one 17-field author row with identity, audience counts, social links, books, and up to 25 homepage article summaries from a URL or handle. Empty or suspended profiles produce no Result charge.