# Tumblr Email Scraper - Keyword & Location Targeting (`scrapido/tumblr-email-scraper`) Actor

🌀 Tumblr Email Scraper pulls blogger and creator emails by keyword and location. 🔓 Domain filters, hidden-address decoding and dedup. 📤 Export Tumblr leads to CSV, JSON or Excel for niche influencer campaigns.

- **URL**: https://apify.com/scrapido/tumblr-email-scraper.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### Tumblr Email Scraper 📬

**Tumblr Email Scraper** is an Apify actor that automates **email scraping for Tumblr**—so marketers, recruiters, and data teams don’t waste days manually hunting for contact emails. Instead of copy-pasting from profiles and scattered pages, it helps you extract public emails at scale, fast, and in a structured dataset for high-ROI lead generation.

***

### What is Tumblr Email Scraper? 🔍

**Tumblr Email Scraper** is an automated web scraping tool (an Apify actor) designed to extract email addresses from Tumblr based on the keywords and filters you choose. It works on publicly available Tumblr pages and saves results to an Apify dataset in a clean, structured format—ideal when you need thousands of Tumblr contacts quickly.

If you’re looking for a **Tumblr email extractor**, a **Tumblr contact scraper**, or a **Tumblr lead generation tool**, this actor helps you turn targeted keyword research into an exportable list for outreach and CRM enrichment. Use it to run bulk email harvesting from Tumblr while controlling cost and run time with `maxEmails`.

***

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

This actor collects public contact data tied to your search inputs. It captures email addresses and the surrounding context so your sales and marketing teams can understand where the contact came from.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `email` | Public email address extracted from Tumblr |
| Identity | `title` | Profile name, business title, or heading text found on the result |
| Context | `description` | Text content associated with the result (helps you review relevance) |
| Discovery | `keyword` | The keyword you provided that surfaced this record |
| Navigation | `url` | Direct link to the Tumblr page related to the record |
| Location | `location` | Location text if available (profile-listed information) |

***

### What Do Results from a Tumblr 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": "Maya Chen",
  "description": "Building brand partnerships and freelance design services. Contact: maya.chen@studioworks.com",
  "url": "https://www.tumblr.com/studioworks/123456789",
  "email": "maya.chen@studioworks.com"
}
```

Your results are saved in your Apify Dataset and can be exported for analysis or outreach workflows (for example via Apify Console).

***

#### Core Features: Tumblr Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ Keyword-Driven Targeting | Use keywords to focus your email harvesting from Tumblr |
| ✅ Location Filter | Add `location` to narrow results to a specific region or city |
| ✅ Custom Domain Filter | Control results using `customDomains` (e.g., `@gmail.com`, `@yahoo.com`) |
| ✅ Configurable Result Cap | Use `maxEmails` to control the maximum number of emails collected |
| ✅ Proxy Support | Built-in proxy support for more reliable scraping at scale |
| ✅ Incremental Dataset Writing | Saves results as they’re found, so you don’t lose everything if a run stops |
| ✅ Structured Dataset Output | Clean fields (`keyword`, `title`, `description`, `url`, `email`) ready for CRM import |
| ✅ Public Web Data Only | Extracts emails and metadata from publicly available sources |
| ✅ Works Without Custom Coding | Marketers and analysts can run Tumblr email scraping via the Apify interface |

***

### Getting Started with Tumblr Email Scraper 🚀

1. **Open Apify Store** — go to [apify.com/store](https://apify.com/store) and find **Tumblr Email Scraper**
2. **Click Try for Free** — sign in or create an Apify account
3. **Open the Input Tab** — configure keywords, optional location, and domain filters
4. **Add Keywords** — start with roles like `manager` or `founder` (or your own terms)
5. **Set Optional Filters** — add `location` and `customDomains` if you want more precise results
6. **Cap Your Results** — set `maxEmails` to control run time and cost
7. **Click Start** — launch the run and watch logs
8. **Access Your Data** — open the dataset to preview and export your Tumblr contact list

First results are typically fast to reach, especially with a focused keyword set and a sensible domain filter.

***

### Ways to Use Tumblr Email Scraper 💡

- 🎯 **Lead Generation:** Build segmented Tumblr email lists for outreach and prospecting
- 📣 **Email Marketing:** Power newsletters and drip campaigns with web scraping emails from relevant creators and businesses
- 🤝 **Talent & Partnerships:** Find contact emails for collaboration and recruiting use cases
- 🔬 **Market Research:** Use OSINT email gathering to understand who’s active in a niche
- 📊 **CRM Enrichment:** Append extracted emails alongside title and page context for cleaner records
- ⚙️ **Data Pipelines:** Feed extracted data harvesting from Tumblr into automated workflows and dashboards

***

#### Input Parameters — Tumblr Email Scraper

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

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | Array | ✅ Yes | — | A list of keywords or queries to target for extracting Tumblr email addresses |
| `location` | String | No | `""` | Location to filter results (leave empty to scrape more broadly) |
| `customDomains` | Array | No | `["@gmail.com", "@yahoo.com"]` | Email domains to keep (example: `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | Integer | No | `20` | Maximum number of emails to collect; helps control scraping time and cost |

***

#### Output Parameters — Tumblr Email Scraper

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The keyword that surfaced this result |
| `title` | Title | text | The profile title/name captured for the result |
| `description` | Description | text | Associated text content that provides context for the contact |
| `url` | Url | link | The direct Tumblr link for this record |
| `email` | Email | text | The extracted public email address |

***

### Why Choose This Tumblr Email Scraper? 🏆

**Tumblr Email Scraper** is built for people who need web scraping emails with usable structure—so you can move from research to outreach quickly. You get keyword-driven targeting, optional location and domain filtering, a configurable `maxEmails` cap, and structured dataset output (`keyword`, `title`, `description`, `url`, `email`). It’s designed to support reliable large-scale runs with proxy support, and results are written incrementally for resilience.

For help or custom solutions, reach out to <scrapidocontact@gmail.com>.

***

### How Many Results Can You Scrape? 📈

Use `maxEmails` to set a cap from **1 to 10,000**. The actual number of emails you receive depends on how many matching Tumblr pages include public emails for your selected keywords and `customDomains`. If you set a large target, runs may take longer. Regardless, the actor stores results in your Apify dataset so you can export whenever you want.

***

### Legal Guidelines for Scraping Tumblr ⚖️

This actor extracts data only from **publicly available sources** on Tumblr. It does not access private, login-only, or password-protected content. You’re responsible for complying with Tumblr’s Terms of Service, privacy regulations, and applicable spam/marketing laws (including consent requirements where relevant). Use extracted emails only for legitimate business purposes. Data removal requests: <scrapidocontact@gmail.com>.

***

### FAQ — Tumblr Email Scraper ❓

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

It uses the keywords and optional filters you provide to find relevant publicly available Tumblr results, then extracts email addresses and related profile context into dataset records.

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

Any public Tumblr profile page that exposes an email address publicly can be included. If a profile does not list a public email address, it won’t contribute an `email` value to your dataset.

#### How did the Tumblr Email Scraper perform in our tests?

Performance depends on the niche and how often the target pages list public emails. With focused keywords and appropriate `customDomains`, you can typically expect stronger yield than broad, generic searches.

#### Why scrape Tumblr for contacts?

Tumblr hosts many niche creators, professionals, and business pages that may publish contact emails. Using a Tumblr email harvester automates a workflow that would otherwise be manual and time-consuming.

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

Pricing is pay-per-result. You can control costs by setting `maxEmails` to the maximum amount you want collected in the run.

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

It helps you build a clean dataset for lead generation: each record includes the keyword used, page context (title/description), the source URL, and the extracted email—making it easier to import into CRMs or outreach tools.

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

Not every Tumblr profile includes a public email address. If you get fewer results than expected, try expanding or refining your `keywords`, adjusting `customDomains`, or adding a broader set of search terms.

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

Start with role- or intent-based keywords (for example, positions like `manager` or `founder`), then refine using `customDomains` to match the email types you want. If you’re targeting a region, add `location` carefully to avoid being too narrow.

***

### Conclusion 🏁

The **Tumblr Email Scraper** is a practical way to extract emails from Tumblr with structured output for analysis and outreach. Whether you’re doing OSINT email gathering, building a lead generation email scraper workflow, or running bulk email extraction, it helps you scale faster with `maxEmails` control.

***

### 🆘 Support & Feedback

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

You can contact the team at <scrapidocontact@gmail.com>.

### Multiple Email Types

**Email Types** replaces the old single Audience Type choice: select as many
kinds of mailbox as you want and the run chases all of them together.

| Type | What it matches |
| --- | --- |
| Personal / free webmail | Gmail, Outlook, Yahoo, iCloud, AOL, Proton, ... |
| Business / corporate | Company domains - free webmail and institutions excluded |
| Education (.edu / .ac) | `.edu`, `.ac.uk`, `.edu.au`, `.ac.in` and other academic suffixes |
| Government (.gov / .mil) | `.gov`, `.mil`, `.gov.uk`, `.gc.ca`, ... |
| Non-profit (.org) | `.org`, `.ngo`, `.org.uk`, ... |

Each selected type contributes its own Google dork patterns *and* its own domain
test, so a result is only kept if it genuinely belongs to the type that found
it. Every row carries an `emailType` field recording which one that was.

Suffixes are matched as real domain suffixes, so `cs.mit.edu` counts as
Education while `notedu.com` does not.

Setting **Custom Email Domains** still overrides everything: an explicit domain
list is a manual override and replaces the type-driven patterns. The legacy
`audienceType` value is still accepted, so saved inputs keep working.

# Actor input Schema

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

A list of keywords or queries to search for.

## `audienceType` (type: `string`):

Business Emails runs contextual discovery patterns tuned for company contact pages ("email us at", "contact@", careers, bookings, ...) and filters out consumer webmail domains. Consumer Emails instead searches gmail.com, yahoo.com, outlook.com, hotmail.com and icloud.com directly.

## `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.

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

Optional manual override — provide specific email domains to search for (e.g. @hubspot.com) instead of using Audience Type. Leave empty to use Audience Type.

## `emailTypes` (type: `array`):

Which kinds of mailbox to hunt for. Pick as many as you like - each type contributes its own set of Google search patterns and its own domain filter, and every result records the type it was found as. Personal = free webmail (Gmail, Outlook, Yahoo, iCloud). Business = company domains, excluding free webmail and institutions. Education = .edu / .ac.uk and friends. Government = .gov / .mil. Non-profit = .org.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "audienceType": "Consumer Emails",
  "maxEmails": 20,
  "customDomains": [],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}
```

# 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"
    ],
    "customDomains": [],
    "emailTypes": [
        "Personal",
        "Business"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/tumblr-email-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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "customDomains": [],
    "emailTypes": [
        "Personal",
        "Business",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/tumblr-email-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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "customDomains": [],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}' |
apify call scrapido/tumblr-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/tumblr-email-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/0cMDKpLHUjGqeQ6rP/builds/8Rg7rGZpZPfu6IcAc/openapi.json