# Medium Profile API (`truefetch/medium-profile-api`) Actor

Medium profile API that converts a URL or handle into one 17-field JSON row with author identity, audience counts, socials, books, and up to 25 homepage article summaries. Empty or suspended profiles produce no Result charge.

- **URL**: https://apify.com/truefetch/medium-profile-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0225 / result

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Medium Profile API is a medium profile api that turns one writer URL or handle into a 17-field JSON record with identity, audience, social, book, and homepage article data.** It gives developers and data teams a point-lookup contract for Medium author enrichment without requiring a Medium account or a standing subscription.

- **One `medium_url` input returns at most one author record.**
- **The Dataset exposes 17 documented top-level fields, including follower and following counts.**
- **Each record can include up to 25 public homepage article summaries with engagement, dates, tags, lock state, and reading minutes.**
- **Missing, suspended, or unreadable profiles finish without a Result charge.**

[**Run a one-result test**](https://apify.com/truefetch/medium-profile-api) · [**View API**](https://apify.com/truefetch/medium-profile-api/api)

The smallest useful successful test is one handle: $0.01 for Actor Start plus $0.03 for one saved Result on the FREE tier, or $0.04 total; a test that saves no profile row does not incur the Result charge.

### What does Medium Profile API do?

Medium Profile API resolves one public Medium writer reference and returns one normalized author snapshot. Supply a full profile URL, an `@handle`, or a bare handle through `medium_url`; the response can include the stable Medium ID, canonical username, display name, profile URL, stored avatar, biography, linked Twitter/X and Mastodon usernames, follower and following counts, book-author status, credited book titles, and a bounded homepage article sample.

The `articles` array contains up to 25 summaries from the writer's public homepage. Each article can carry its source ID, title, URL, subtitle, clap and response counts, reading minutes, publication and update timestamps, tags, lock state, and a stored preview-image URL. `article_count` reports how many items were returned in the current snapshot.

This Actor is a profile lookup, not a topic search or a complete content archive. It does not enumerate follower lists, crawl publications, retrieve full article bodies, or paginate through a writer's entire history. It is independent and is not affiliated with, endorsed by, or operated by Medium.

### How do I run Medium Profile API?

Run Medium Profile API by passing one supported writer reference in the required `medium_url` field.

1. Open the [Store input form](https://apify.com/truefetch/medium-profile-api).
2. Replace the prefilled `https://medium.com/@MediumStaff` value if you want another writer.
3. Start the Actor and wait for its terminal status.
4. Read the single default Dataset item, or export it as JSON, CSV, Excel, XML, or RSS.

The smallest runnable input uses the same public profile as the prefill:

```json
{
  "medium_url": "https://medium.com/@MediumStaff"
}
```

One run accepts one writer reference and saves at most one Result. For a list of handles, call the Actor once per value through the API, an Apify task, or your workflow system.

### What data does Medium Profile API return?

Medium Profile API returns one 17-field author record when the requested profile is usable; unavailable source values stay null or absent instead of being guessed.

| Group | Fields | Meaning |
| --- | --- | --- |
| Identity | `platform`, `id`, `username`, `name`, `profile_url`, `avatar_url`, `bio` | Source label, stable author identity, canonical profile, stored avatar, and public biography |
| Connections | `twitter_username`, `mastodon_username` | Social usernames linked from the profile |
| Audience | `follower_count`, `following_count` | Integer audience values at retrieval time |
| Books | `is_book_author`, `book_titles` | Medium's book-author marker and credited titles |
| Homepage activity | `articles`, `article_count` | Up to 25 article summaries and the number included |
| Processing | `processor`, `processed_at` | Producing Actor reference and UTC snapshot time |

This illustrative JSON is abbreviated to one article object; a populated record can contain up to 25 article summaries.

```json
{
  "platform": "Medium",
  "id": "medium-staff-example-id",
  "username": "MediumStaff",
  "name": "Medium Staff",
  "profile_url": "https://medium.com/@MediumStaff",
  "avatar_url": "https://api.apify.com/v2/key-value-stores/example/records/avatar.jpg",
  "bio": "Updates and stories from Medium.",
  "twitter_username": null,
  "mastodon_username": null,
  "follower_count": 1000,
  "following_count": 10,
  "is_book_author": false,
  "book_titles": [],
  "articles": [
    {
      "id": "article-example-id",
      "title": "An illustrative Medium update",
      "url": "https://medium.com/@MediumStaff/article-example-id",
      "subtitle": "An abbreviated example for the Dataset shape.",
      "clap_count": 100,
      "response_count": 5,
      "reading_minutes": 4.2,
      "published_at": "2026-08-01T12:00:00+00:00",
      "updated_at": "2026-08-01T12:00:00+00:00",
      "tags": ["medium", "publishing"],
      "is_locked": false,
      "image_url": null
    }
  ],
  "article_count": 1,
  "processor": "https://apify.com/truefetch/medium-profile-api",
  "processed_at": "2026-08-12T18:00:00+00:00"
}
```

Values in the illustrative row demonstrate types and nesting, not current facts about the example account. Use the live Result row as the authoritative snapshot.

### What inputs can I configure?

Medium Profile API has exactly one public input and requires it on every run.

| Input | Type | Required | Behavior | Example |
| --- | --- | --- | --- | --- |
| `medium_url` | string | Yes | Medium profile URL, `@handle`, or bare handle; resolves one author and produces at most one record | `https://medium.com/@MediumStaff` |

There are no credential, cookie, article-limit, keyword, country, language, filter, or pagination inputs. Medium documents the supported writer profile forms in its [official profile URL guide](https://help.medium.com/hc/en-us/articles/115004746707-Your-profile-page-URL), including the familiar `medium.com/@username` pattern.

### What platforms and markets does Medium Profile API cover?

Medium Profile API covers publicly readable writer profiles on medium.com regardless of the writer's language or location. Medium is a global publishing platform, so the Actor has no country, marketplace, or language selector; it returns the source text and counts exposed for the requested profile.

Custom publication domains do not create a separate market dimension. The lookup is centered on the writer's canonical Medium identity. Suspended, nonexistent, or persistently unreadable profiles are clean empty outcomes rather than partial synthetic rows.

The activity scope is deliberately narrower than the profile scope. A writer record can include only the articles available through the public homepage sample, up to 25 items, so the output should not be treated as a complete bibliography.

### Why use Medium Profile API?

Medium Profile API is useful when a developer needs one predictable author object rather than a rendered profile page.

| Capability | Benefit for a data workflow |
| --- | --- |
| Three accepted reference shapes | Normalize mixed CRM columns containing URLs, `@handles`, and bare handles without a separate cleanup step |
| Integer audience fields | Score or sort writers using `follower_count` and `following_count` without parsing abbreviated page text |
| Stable 17-field contract | Join every populated writer record to the same downstream table or model |
| Linked social and book context | Connect an author to other public identities and distinguish book authors from ordinary accounts |
| Engagement-bearing homepage sample | Use claps, responses, tags, dates, and reading minutes to assess recent activity and subject fit |
| No-charge empty Result | Test stale or uncertain handles without paying the profile Result price when no row is saved |

The main trade-off is the one-writer-per-run contract. It keeps output and billing explicit, but a batch enrichment job must loop calls or schedule tasks externally.

### Who is Medium Profile API for?

Medium Profile API is for developers, data teams, researchers, and operations teams that already know the writer they want to resolve. Common workflows include enriching newsletter authors in a CRM, qualifying speakers or experts, comparing the public audience of tracked writers, linking a Medium identity to Twitter/X or Mastodon, and monitoring a portfolio of creators over time.

Growth and partnerships teams can export the flat profile fields to a spreadsheet, while engineering teams can consume the same row through HTTP, an SDK, or MCP. `articles` is the only nested top-level field that usually needs a separate transform for tabular systems.

It is not the right product for users starting from a topic query, building a full-text article corpus, enumerating followers, or reconstructing a complete publication history. Those goals need a different retrieval contract.

### How can I use Medium Profile API through the API or MCP?

Use the Actor name `truefetch/medium-profile-api` in API and MCP calls; the name form remains the stable public integration reference.

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~medium-profile-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" -H "Content-Type: application/json" -d '{"medium_url":"https://medium.com/@MediumStaff"}'
```

The synchronous Dataset-items endpoint returns a JSON array containing zero or one object. Store the Apify token in a secret manager or platform credential rather than source code.

For MCP clients, connect to Apify's hosted Streamable HTTP endpoint:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

After connecting, discover `truefetch/medium-profile-api` and pass `medium_url: https://medium.com/@MediumStaff`. The [API page](https://apify.com/truefetch/medium-profile-api/api) provides generated JavaScript and Python examples plus the OpenAPI definition for the same input and Dataset contract.

### How much does Medium Profile API cost?

Medium Profile API costs $0.03 per saved profile Result on the FREE tier plus $0.01 for Actor Start, so the smallest successful test costs $0.04.

| Event | Billing unit | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Start | Run start; one event per GB of memory, minimum one | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Result | One saved author profile row | $0.03000 | $0.02700 | $0.02400 | $0.02250 | $0.02250 | $0.02250 |

At the default 256 MB memory, Apify charges the minimum one Actor Start event. The one required calculation is therefore $0.01 Start + $0.03 Result = $0.04 for one successful FREE-tier lookup. If a missing, suspended, or unreadable profile produces no Dataset row, the Result event is not charged. Prices can change, so verify the [live pricing panel](https://apify.com/truefetch/medium-profile-api) before planning a large enrichment batch.

### How does Medium Profile API compare with alternatives?

Medium Profile API fits intermittent, point-based writer enrichment where a stable schema and per-result billing matter. Manually reading a profile is free and often best for one visual check, but it does not provide a repeatable 17-field export or an automated audience snapshot.

Medium's official API documentation is [archived and says the API is no longer supported](https://github.com/Medium/medium-api-docs). Historical official integrations can explain older publishing workflows, but they are not a current general profile-data service. Building separate page-reading, image-storage, normalization, scheduling, and export steps gives a team more control, while this Actor bundles those public outcomes behind one input and Dataset contract.

An unnamed subscription data category can suit continuous high-volume lookup programs with negotiated quotas or broader endpoints. This Actor is a better fit for on-demand author resolution without a standing subscription. Choose another path when you need topic search, full article bodies, follower lists, publication membership, or complete author history; use the sibling [Medium API](https://apify.com/truefetch/medium-api) when keywords are the entry point.

### What are the limits and troubleshooting steps?

Medium Profile API is limited to one publicly readable writer per run and a maximum 25-item public homepage sample.

- **Empty Dataset →** the handle may be missing, suspended, or unreadable. Check spelling and retry with `https://medium.com/@handle`.
- **Fewer than 25 articles →** the writer's public homepage supplied fewer items. Trust `article_count` as the returned sample size.
- **Null bio, social username, or book field →** Medium did not expose that value. Keep null as a meaningful source outcome.
- **Counts differ across runs →** audience and engagement values are snapshots. Compare them using `processed_at`.
- **Missing avatar or article image →** the source lacked the asset or that individual file was not stored. Other profile and article fields can still be valid.
- **Need a list of writers →** submit one `medium_url` per Actor run through an API loop, task schedule, or workflow queue.

If a known-good public handle repeatedly fails, open the [Issues tab](https://apify.com/truefetch/medium-profile-api/issues) and include the run ID, exact input, expected record, and affected field. A minimal reproducible report uses `{"medium_url":"https://medium.com/@MediumStaff"}`.

### Frequently asked questions

Medium Profile API answers the most common questions about input shape, field meaning, limits, scheduling, and billing.

#### Is there a medium user api for follower data?

Yes. This medium user api returns `follower_count` and `following_count` as integer fields when Medium exposes them, together with identity, bio, social, book, and homepage activity data.

#### How do I look up medium writer by handle?

Pass a full profile URL, `@handle`, or bare handle in `medium_url`; all supported forms resolve to the canonical writer identity returned by Medium.

#### Is there a free Medium profile API?

Manual profile viewing is free, but this Actor uses pay-per-event pricing. The smallest successful FREE-tier run is $0.04, and a run that saves no profile row avoids the $0.03 Result charge.

#### Can I schedule runs to monitor Medium writers over time?

Yes. Save a task for each `medium_url`, schedule it in Apify, and compare `follower_count`, `following_count`, article engagement, and `processed_at` across snapshots.

#### Does the API return a writer's complete article history?

No. `articles` is a public homepage sample capped at 25 summaries, not a complete archive, feed, or full-text corpus.

#### What happens for a suspended or nonexistent profile?

The run ends without a usable Dataset row after the source outcome is confirmed. Actor Start remains billable, but no Result event is charged.

#### Do I need Medium credentials or cookies?

No. The only public input is `medium_url`; the schema has no account, token, cookie, or session field.

#### Can I export the result to a spreadsheet or CRM?

Yes. Export the Dataset as CSV or Excel, or map the JSON row through an integration. The profile fields are flat; only the `articles` array is nested.

### Related TrueFetch Actors

Three TrueFetch Actors extend the same workflow in distinct directions.

- [**Medium API**](https://apify.com/truefetch/medium-api) — search Medium articles by keyword and collect full public article rows when a topic starts the workflow.
- [**Reddit User Profile**](https://apify.com/truefetch/reddit-user-profile) — add account-level community identity, reputation, and history to cross-platform people research.
- [**LinkedIn Profile API**](https://apify.com/truefetch/linkedin-profile-api) — add professional roles, experience, education, activity, and displayed counts to a writer record.

### Support

Support is available through the Store surfaces and the TrueFetch community. Use the [Store page](https://apify.com/truefetch/medium-profile-api) for input and pricing, the [API reference](https://apify.com/truefetch/medium-profile-api/api) for integration examples, the [Issues tab](https://apify.com/truefetch/medium-profile-api/issues) for reproducible defects, and the [TrueFetch community](https://t.me/TrueFetch) for product questions.

[**Test one Medium writer**](https://apify.com/truefetch/medium-profile-api) · [**Open the API reference**](https://apify.com/truefetch/medium-profile-api/api)

**Last Updated:** August 12, 2026

# Actor input Schema

## `medium_url` (type: `string`):

A Medium profile URL, @handle, or bare handle to resolve through the API. One input produces at most one author record.

## Actor input object example

```json
{
  "medium_url": "https://medium.com/@MediumStaff"
}
```

# Actor output Schema

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

The 17-field author row with optional profile details, nested articles including reading minutes, and KVS-backed images; unavailable source keys are omitted.

# 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 = {
    "medium_url": "https://medium.com/@MediumStaff"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/medium-profile-api").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 = { "medium_url": "https://medium.com/@MediumStaff" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/medium-profile-api").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 '{
  "medium_url": "https://medium.com/@MediumStaff"
}' |
apify call truefetch/medium-profile-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/medium-profile-api"
        }
    }
}

```

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/BFT2jiQFlA5LzwMAM/builds/EXNby0WkDCzz8fOeI/openapi.json