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

👻 Ghost Email Scraper pulls newsletter and blog owner emails with keyword and location filters. 🎯 Limit to specific domains, decode obfuscated addresses and drop duplicates. 📰 Built for sponsorship outreach.

- **URL**: https://apify.com/parse-point/ghost-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

### Ghost Email Scraper

**Ghost Email Scraper** is an Apify actor that automates *mass email extraction* from Ghost, solving the biggest pain point in contact discovery: manual research doesn’t scale. If you’re a marketer, recruiter, or analyst building an email list, this ghost email collector helps you scrape public email addresses faster—so you can drive better ROI with data enrichment at scale.

***

### What is Ghost Email Scraper? 🔍

Ghost Email Scraper is an automated web scraping tool (an Apify actor) built for extracting email addresses from Ghost based on the keywords and filters you provide. It works by pulling relevant Ghost profiles and harvesting publicly listed emails, along with useful context like profile title, description, and direct URLs. This addresses the time sink of manual lead generation and replaces slow, copy-paste research with a repeatable email harvesting workflow. It’s ideal for marketers, recruiters, sales teams, and data analysts who want thousands of contacts in minutes. Use it as a Ghost email extractor, a Ghost contact scraper, or a ghost lead generation tool to accelerate outreach and email list building.

***

### What Data Does a Ghost Email Scraper Collect? 📊

Ghost Email Scraper collects contact and profile context needed for website email harvesting and email list building. You’ll get email addresses tied to discovery keywords, plus metadata that helps you understand who the contact is and where to navigate next.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `email` | Public email address found in Ghost profiles |
| Identity | `title` | Profile title or business name text used in the listing |
| Context | `description` | The profile’s description or summary text that may contain contact context |
| Discovery | `keyword` | The search keyword/term that surfaced this result |
| Navigation | `url` | Direct link to the Ghost profile |
| Location | *(not included)* | Location is not part of the dataset schema for this actor |

> Note: The dataset schema for this actor includes `keyword`, `title`, `description`, `url`, and `email`—only those fields are guaranteed in exports.

***

### What Do Results from Ghost Email Scraper Look Like? 👀

Each result is a structured JSON record saved to your Apify dataset. Here's a real example:

```json
{
  "keyword": "founder",
  "title": "Nina Patel",
  "description": "Founder & Builder at Northwind Studio. Contact for partnerships and product inquiries.",
  "url": "https://ghost.org/northwind-studio/team/nina-patel",
  "email": "nina.patel@northwindstudio.com"
}
```

Results are stored in your Apify dataset (JSON by default) and can be exported to CSV from the Apify Console.

***

#### Core Features: Ghost Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Keyword-Driven Targeting** | Use keywords to shape your contact discovery for lead generation |
| ✅ **Location Filter** | Optionally narrow results using the `location` input |
| ✅ **Custom Domain Filter** | Use `customDomains` to focus on specific email domains (e.g., `@gmail.com`) |
| ✅ **Configurable Result Cap** | Set `maxEmails` to control run scope for more predictable outcomes |
| ✅ **Proxy Support** | Built-in proxy support to help scraping stay reliable at scale |
| ✅ **Incremental Dataset Writes** | Saves results incrementally to your dataset so you keep what’s been found |
| ✅ **Structured Dataset Output** | Clean, labeled records ready for CRM, spreadsheet, or automation workflows |
| ✅ **No Login Required** | Works with publicly accessible Ghost data rather than private accounts |

***

### Getting Started with Ghost Email Scraper 🚀

1. **Open Apify Store** — Go to [apify.com/store](https://apify.com/store) and search **Ghost Email Scraper**
2. **Click Try for Free** — Sign in or create a free Apify account
3. **Open the Input Tab** — Configure your scraping parameters
4. **Add Keywords** — Enter role or intent keywords like `manager` or `founder`
5. **Set Optional Filters** — Add a `location` and/or `customDomains` to narrow email harvesting
6. **Cap Your Results** — Set `maxEmails` to limit how many emails to collect
7. **Click Start** — Launch the run and watch progress in logs
8. **Access Your Data** — Open the dataset and export when you’re ready (JSON/CSV)

***

### Ways to Use Ghost Email Scraper 💡

- 🎯 **Lead generation** — Build segmented email list building sets from targeted Ghost keywords
- 📩 **Website email harvesting** — Scrape public email addresses for outreach and sales prospecting
- 🧪 **Contact discovery** — Find relevant contacts for research, data enrichment, and anonymous email scraping workflows
- 📊 **CRM enrichment** — Populate a CRM with structured records containing `url` + extracted `email`
- ⚙️ **Data pipelines** — Feed results into downstream analysis or bulk email verification routines
- 🛡️ **Anti-spam compliance workflows** — Use the collected list as input for your own validation steps before sending

***

#### Input Parameters — Ghost Email Scraper

Provide input to the actor via an `input.json` payload.

Example:

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

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | Array | ✅ Yes | — | A list of keywords to use to find relevant Ghost profiles |
| `location` | String | No | `""` | Location to filter search results (leave empty for no location filter) |
| `customDomains` | Array | No | `["@gmail.com","@yahoo.com"]` | Email domains to keep; helps you focus extraction on specific provider types |
| `maxEmails` | Integer | No | `20` | Maximum number of emails to collect (the actor stops when the limit is reached) |

***

#### Output Parameters — Ghost Email Scraper

The actor writes results to the **Ghost Emails Dataset** (“Scraped Leads”). Exports follow this dataset schema exactly.

Example:

```json
[
  {
    "keyword": "creative director",
    "title": "Alex Rivera",
    "description": "Creative Director at Studio Co. | Available for freelance work and collaborations.",
    "url": "https://ghost.org/studio-co/people/alex-rivera",
    "email": "alex.rivera@studioco.com"
  }
]
```

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The keyword used to discover this result |
| `title` | Title | text | The profile’s title or name text as captured in the result |
| `description` | Description | text | Profile description/summary text associated with the contact |
| `url` | Url | link | Direct link to the Ghost page for this lead |
| `email` | Email | text | Extracted public email address |

***

### Why Choose This Ghost Email Scraper? 🏆

Ghost Email Scraper is a purpose-built ghost email collector for extracting public emails from Ghost with structured output you can use immediately. It’s built for speed and scalability (keyword-first lead generation) and gives you dataset-ready records for contact discovery and data enrichment. With proxy support and a controllable `maxEmails` cap, it’s easier to balance yield, time, and cost compared to ad-hoc manual scraping.

For custom features or tailored solutions, reach out at `[hello.parsepoint@gmail.com](mailto:hello.parsepoint@gmail.com)`.

***

### How Many Results Can You Scrape? 📈

Use `maxEmails` to set a cap from 1 up to 10,000. Actual results depend on how many Ghost profiles match your provided `keywords` and `customDomains` and actually display public emails. For larger runs, expect longer runtimes as the actor processes more potential matches.

***

### Legal Guidelines for Scraping Ghost ⚖️

Ghost Email Scraper is designed to work with **publicly available data** on Ghost. It does not access private profiles or any password-protected content. You are responsible for complying with applicable laws and platform policies, including privacy regulations and anti-spam compliance requirements. Only use extracted data for legitimate purposes, and follow your organization’s governance rules for consent, retention, and outreach.

Data removal requests: <hello.parsepoint@gmail.com>.

***

### FAQ — Ghost Email Scraper ❓

#### How does the Ghost Email Scraper identify data?

Ghost Email Scraper uses the `keywords` you provide (optionally combined with `location` and `customDomains`) to find relevant Ghost profiles, then extracts email addresses and associated profile context into the dataset.

#### What Ghost profile types can I scrape?

You can target public Ghost profiles that contain email addresses that are publicly visible. The actor focuses on extracting emails and related metadata from what is publicly accessible.

#### What does “customDomains” do?

`customDomains` limits the extracted email addresses to specific email domains (for example, `@gmail.com` and `@yahoo.com`). This is useful for tighter lead generation tool workflows where you only want certain provider types or formats.

#### Why scrape Ghost for contacts?

Ghost hosts creators and businesses that may display contact emails publicly. Automating website email harvesting helps you scale contact discovery and speed up web scraping workflows that would otherwise take too long manually.

#### How much does the Ghost Email Scraper cost?

This actor is designed for pay-per-result style usage in Apify runs. Use `maxEmails` to cap the run and control how many emails you attempt to collect.

#### How does the Ghost Email Scraper help my business?

It turns Ghost profile data into a clean dataset for email list building, CRM enrichment, and outreach readiness. Since results are structured, you can connect them to downstream workflows like bulk email verification and data enrichment.

#### What challenges should I expect when using the Ghost Email Scraper?

Not every Ghost profile will include a public email address, so output volume depends on your keyword targeting and `customDomains`. If you’re not getting enough results, try wider keyword coverage or add additional relevant email domains.

#### How do I choose a high-performing Ghost Email Scraper setup?

Start with strong, role-focused keywords (e.g., `manager`, `founder`), choose `customDomains` that match your outreach criteria, and set `maxEmails` based on your budget and desired coverage. Then review the dataset and iterate your keyword/domain strategy for better yield.

***

### Conclusion 🏁

Ghost Email Scraper is a fast, reliable way to extract public emails from Ghost at scale. Whether you’re building a lead list, enriching your CRM, or powering outreach campaigns, you can start with keyword targeting, export structured results, and move from research to action quickly.

***

### 🆘 Support & Feedback

Have a question or feature request for the Ghost Email Scraper?

- ✨ **Custom Solutions & Feature Requests:** Contact our team at `[hello.parsepoint@gmail.com](mailto:hello.parsepoint@gmail.com)`
- 💬 **Need help with your run setup?** Send a message and include your target keywords and desired email domains for faster assistance

### 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/ghost-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/ghost-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/ghost-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/ghost-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/H5J8SkSTF2Jq7ZlDd/builds/3VwC5fWB1Qm7BCgW7/openapi.json