# Medium Email Scraper - Keyword Search & Domain Filter (`parse-point/medium-email-scraper-lightning-fast-and-accurate`) Actor

📰 Medium Email Scraper pulls writer and publication emails with your keywords and location filters. 🎯 Restrict to specific domains, decode obfuscated addresses and skip duplicates. ✍️ Built for content partnerships.

- **URL**: https://apify.com/parse-point/medium-email-scraper-lightning-fast-and-accurate.md
- **Developed by:** [Parse Point](https://apify.com/parse-point) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Email Scraper

**Medium Email Scraper** helps you find publicly available contact emails from Medium using targeted keywords, making it a practical medium email extractor for research, outreach, and medium lead generation. It’s ideal when you want to scrape Medium emails at scale without spending hours on manual review.

### What Does Medium Email Scraper Do? 🤖

Medium Email Scraper scrapes public Medium-related pages using the keywords you provide, then collects matching contact emails that fit your chosen email domains. You can optionally add a location filter and set a maximum number of emails to collect, which makes it easy to control scope and costs. The actor exports results into a structured dataset with the keyword, page title, description, URL, and email. For marketers and analysts, this is a faster way to automate medium.com email scraper workflows than checking pages one by one.

### What Can Medium Email Scraper Extract? 📊

This actor captures a focused set of fields that help you organize leads and trace where each contact came from. It’s useful for medium newsletter email extractor workflows, medium author email finder research, and medium contact scraper tasks where clean, exportable data matters.

| Data Type | Field Name | Description |
|---|---|---|
| Discovery | `keyword` | The keyword that led to the result |
| Identity | `title` | The page title associated with the result |
| Context | `description` | The extracted page description or snippet text |
| Navigation | `url` | The page URL for the result |
| Contact | `email` | The public email address found in the result |

#### Key Features of Medium Email Scraper ⚡

- ✅ **Keyword-Driven Search:** Uses your keywords to find relevant Medium profiles and pages, which makes medium writer email scraper and medium publication email extractor workflows more precise.
- 🌍 **Optional Location Filter:** You can narrow results by location when you need a more targeted medium profile email scraper run.
- 📧 **Custom Domain Filtering:** Focus on specific email domains like `@gmail.com` or `@yahoo.com` for cleaner outreach lists.
- 🔄 **Reliable Scraping:** Built for consistent public web data collection with retries and fallbacks for resilience.
- 📊 **Structured Dataset Output:** Saves results in a clear table format that is easy to export and review.
- 💾 **Incremental Saving:** Results are pushed as they are found, so you do not lose progress during longer runs.
- ⚙️ **Configurable Volume:** `maxEmails` helps you cap collection size and manage runtime.
- 🚀 **SEO-Friendly Lead Discovery:** Great for scrape medium emails, medium email harvesting, and medium outreach emails use cases.

### How to Use Medium Email Scraper 🚀

1. **Open the Actor** — Start the Medium Email Scraper in Apify Console.
2. **Add Keywords** — Enter one or more search terms such as job titles, roles, or niche topics.
3. **Set Filters** — Optionally add a location and choose custom email domains.
4. **Choose the Limit** — Set `maxEmails` to control how many contacts you want.
5. **Run the Actor** — Launch the task and monitor the live logs.
6. **Review the Dataset** — Open the dataset tab to see scraped results as they arrive.
7. **Export the Data** — Download the output for CRM import, analysis, or outreach.

No coding required.

### Medium Email Scraper Output Format 📦

The actor saves results to an Apify dataset in structured JSON format, ready for export or downstream use in your medium data scraper or medium lead generation workflow.

#### Input Example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

#### Output Example

```json
[
  {
    "keyword": "founder",
    "title": "Alex Morgan",
    "description": "Founder and product strategist sharing growth insights and startup lessons.",
    "url": "https://medium.com/@alexmorgan",
    "email": "alex.morgan@gmail.com"
  }
]
```

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The keyword that produced the result |
| `title` | Title | text | The title associated with the result |
| `description` | Description | text | The page description or snippet text |
| `url` | Url | link | The page URL |
| `email` | Email | text | The public email address found in the result |

### 🎯 Use Cases of Medium Email Scraper

**B2B Lead Generation:** Use Medium email extraction tool workflows to build targeted prospect lists from public Medium content and support outbound campaigns.

**Email Marketing Campaigns:** Collect public contacts for newsletters, promotions, and follow-up sequences, especially when you need medium outreach emails from a niche audience.

**Research and Discovery:** Track themes, authors, and public contact information across Medium profiles and publications for qualitative research.

**CRM Enrichment:** Add `keyword`, `title`, `description`, `url`, and `email` data to existing contact records for more complete lead profiles.

**Audience Building:** Find relevant public contacts around topics, roles, and publications to support long-term medium lead generation efforts.

### How Much Will Medium Email Scraper Cost You? 💰

Medium Email Scraper is designed to help you control spend with the `maxEmails` limit, so you only collect as much data as you need. Pricing on Apify depends on your usage and results volume, and the actor stops once the configured limit is reached. For budget-conscious runs, start with a smaller `maxEmails` value and expand only if you need more coverage. This is especially helpful for larger medium email harvesting jobs.

### Is It Legal to Scrape Medium? ⚖️

This actor only works with publicly available data on Medium. It does not access private profiles, logins, or restricted content. As with any public web data workflow, you are responsible for following Medium’s terms, applicable privacy laws, and anti-spam rules in your region. Use the data for legitimate purposes such as research, outreach, or lead generation. If you have concerns or requests, contact <hello.parsepoint@gmail.com>.

### Medium Email Scraper Input Parameters 📋

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | Array | ✅ Yes | `["manager","founder"]` | A list of keywords or queries to search for. |
| `location` | String | No | `""` | Location to filter search results. Leave it empty if you do not want to narrow the search by place. |
| `customDomains` | Array | No | `["@gmail.com","@yahoo.com"]` | A list of custom email domains to match, such as `@gmail.com` or `@yahoo.com`. |
| `maxEmails` | Integer | No | `20` | Maximum number of emails to collect before the actor stops. |

### During the Actor Run ⏱️

You can follow progress in the Apify Console logs while the actor runs. Results are saved to the dataset in real time, so you can start reviewing them before the run finishes. Runtime depends on your keywords, domain filters, and `maxEmails` setting, and larger searches can take longer. If results are limited, try broader keywords or additional email domains to improve coverage.

### Final Note ✉️

Start collecting Medium emails in minutes with the **Medium Email Scraper**. It’s a simple, scalable way to automate public contact discovery for research and outreach. Questions? Reach us at <hello.parsepoint@gmail.com>.

### FAQ — Medium Email Scraper ❓

#### How does Medium Email Scraper find emails?

Medium Email Scraper uses your keywords and email-domain filters to find relevant contacts from publicly available sources on Medium. It then extracts publicly listed email addresses and saves them to the dataset.

#### What types of Medium profiles can I scrape?

You can scrape public Medium profiles, pages, and publications that display an email address in publicly available content. If no public email is listed, the actor will not create one.

#### Why use a Medium email scraper instead of manual research?

A Medium email scraper saves time by collecting contacts automatically across multiple keywords and domains. That makes it far more efficient than checking each profile or publication one by one.

#### How much does Medium Email Scraper cost to use?

Cost depends on your Apify usage and how much data you collect. The `maxEmails` setting helps you limit runtime and keep each run focused on the amount of data you actually need.

#### What is the best way to get better results from a medium.com email scraper?

Use specific keywords, try related search terms, and include a few email domains that match your target audience. Broader keyword sets often improve results for medium data scraper campaigns.

#### Can I use Medium Email Scraper for lead generation?

Yes, it is well suited for medium lead generation because it collects public contact details tied to relevant keywords. That makes it useful for outreach lists, prospecting, and research.

#### What if I need help or want a custom feature?

If you need help, have a bug report, or want a tailored solution, contact <hello.parsepoint@gmail.com>.

### 🆘 Support & Feedback

Found a bug or need a custom feature for the **Medium Email Scraper**?

- 🐞 **Bug Reports:** Reach out with the issue details
- ✨ **Custom Solutions & Feature Requests:** Contact our team for tailored help
- 📧 **Email:** <hello.parsepoint@gmail.com>

### Run Memory

**Skip keywords already scraped in a previous run** - the actor keeps a
persistent record of every keyword it finishes, in a named key-value store that
survives between runs. Turn this on and a repeat run silently drops the keywords
it has already covered, so a scheduled job over a fixed list only pays for new
ground.

A keyword is identified by the keyword *plus* the set of email domains it was
searched against, so re-running `fitness` against a new domain list is correctly
treated as new work rather than a duplicate.

**Reset keyword history** - wipe that record before the run starts, so
everything counts as new again.

**Max emails per keyword** - cap how many results any single keyword may
produce before the actor moves on to the next one. Stops one broad term from
consuming the entire run budget. `0` means no per-keyword limit.

These sit alongside the existing address-level deduplication: *Skip previous
runs* prevents re-pushing an individual mailbox, while *Skip duplicate keywords*
prevents re-running the search at all.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `decodeProtectedEmails` (type: `boolean`):

Read addresses the page hides behind Cloudflare protection or HTML entities. These are invisible to a plain text scan.

## `decodeWrittenEmails` (type: `boolean`):

Read addresses written to defeat scrapers, such as 'name \[at] example \[dot] com'.

## `decodeEncodedEmails` (type: `boolean`):

Read addresses stored base64-encoded in the page markup.

## `mergeAliasDuplicates` (type: `boolean`):

Collapse different spellings that reach the same inbox (e.g. j.o.h.n+news@gmail.com and john@gmail.com) into a single result, so you are not billed twice for one lead.

## `skipPreviousRuns` (type: `boolean`):

Do not return leads that an earlier run of this Actor already returned. Skipped leads are never charged.

## `duplicateHandling` (type: `string`):

What to do when several spellings reach the same inbox: merge them into one result, keep them apart but flag them, or keep everything as found.

## `skipDuplicateKeywords` (type: `boolean`):

Remember every keyword this actor completes and skip it next time. Ideal for a scheduled run over a fixed keyword list - you only pay for ground you have not covered. A keyword searched against a different set of email domains counts as new work, not a duplicate.

## `resetKeywordHistory` (type: `boolean`):

Clear the remembered keywords before this run starts, so everything is treated as new again. Use after changing your target list.

## `maxEmailsPerKeyword` (type: `integer`):

Stop collecting for a keyword once it has produced this many results, then move on to the next one. Keeps one broad term from consuming the whole run. Leave at 0 for no per-keyword limit.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "decodeProtectedEmails": true,
  "decodeWrittenEmails": true,
  "decodeEncodedEmails": true,
  "mergeAliasDuplicates": true,
  "skipPreviousRuns": false,
  "duplicateHandling": "merge",
  "skipDuplicateKeywords": false,
  "resetKeywordHistory": false,
  "maxEmailsPerKeyword": 0
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parse-point/medium-email-scraper-lightning-fast-and-accurate").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parse-point/medium-email-scraper-lightning-fast-and-accurate").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call parse-point/medium-email-scraper-lightning-fast-and-accurate --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parse-point/medium-email-scraper-lightning-fast-and-accurate"
        }
    }
}

```

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/UKYGDrApFsmmjLkfN/builds/IrPfR0rXqLNUYqdAF/openapi.json