# Dev.to Email Scraper (`neuro-scraper/dev-to-email-scraper`) Actor

Dev.to Email Scraper SD - Dev.to Email Scraper is a lead generation tool that extracts leads with public contact emails, account names and profile URLs from DEV Community results by keyword, location and email domain - DEV Community email extractor.

- **URL**: https://apify.com/neuro-scraper/dev-to-email-scraper.md
- **Developed by:** [Neuro Scraper](https://apify.com/neuro-scraper) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 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.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Dev.to Email Scraper - extract developer writer emails from DEV Community results

The **Dev.to Email Scraper** is an Apify Actor that collects publicly indexed contact emails tied to DEV Community profiles, articles and series. You supply keywords, optional location and the email domains you care about, and it returns a clean dataset of developer-writer leads.

DEV is where developers publish tutorials, retrospectives and opinion pieces, and where they say what they are available for - which is what makes the Dev.to Email Scraper productive. Bios carry "open to consulting" lines, article sign-offs carry a personal address, and organisation pages carry a team inbox.

This is the tool people mean when they search for dev.to writer outreach, a way to reach technical bloggers for a DevRel programme, or a DEV Community email extractor that produces a spreadsheet instead of one address at a time.

#### What the Dev.to Email Scraper actually reads

The Dev.to Email Scraper reads **only what Google has already indexed** on `dev.to`. It builds Google queries with the `site:` operator, fetches result pages through the Apify GOOGLE_SERP proxy, and extracts emails from titles and snippets.

It does **not** log into DEV, call the Forem or DEV API, or open an article directly. There is no browser, no JavaScript rendering, no authentication and no cookies anywhere in the pipeline.

An address in an article's closing paragraph is reachable here only because Google indexed that article - not because the Actor crawled the site.

#### Who the Dev.to Email Scraper is built for

DevRel teams building a launch list, developer-tool marketers looking for tutorial authors, content agencies sourcing subject-matter experts, and recruiters who value people that can explain their work all need the same thing: a repeatable way to turn a technical topic into contactable writers.

The Dev.to Email Scraper turns "TypeScript author, Gmail addresses" into rows you can filter, dedupe and export as CSV, JSON or Excel, or pull straight from the Apify API.

***

### Key features of the Dev.to Email Scraper

| Feature | What it does |
|---|---|
| Google `site:` dorking | Queries `dev.to` through the Apify GOOGLE_SERP proxy |
| Query expansion | Runs base, quoted and `intitle:` variants plus one variant per query modifier; base queries run first |
| Domain-filtered extraction | Keeps only emails ending in your `customDomains` values |
| Global deduplication | One row per unique email across every query and every page of the run |
| Obfuscation handling | Understands `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the full-width `＠` |
| Junk filter | Rejects placeholders such as `email@`, `yourname@`, `test@`, `xxx@` and single-character locals |
| Boundary-correct matching | `@gmail.com` never matches inside `@gmail.company` or `@gmail.com.br` |
| Soft-wrap repair | Drops a hit that is only the tail of another email in the same result block |
| Structural parsing | Locates the `<h3>` title then the smallest surrounding block, instead of relying on Google's CSS class names |
| Handle resolution | Recovers the `dev.to/{username}` handle and ignores non-profile paths such as `/t/`, `/tags` and `/search` |
| Label awareness | Recognises how Google labels the site as `DEV Community`, `DEV` or `dev.to` when parsing an account name |
| Whole-page fallback | If Google's markup changes, the run degrades to "emails without account details" rather than "no emails" |
| Block detection | CAPTCHA, "unusual traffic" and consent pages are detected and retried, not counted as empty |
| Retries and backoff | Up to 3 attempts per page with exponential backoff and a fresh proxy session per request |
| Requeue of failures | Blocked or failed queries are re-queued once at the end of the run |
| Async concurrency | An `asyncio` worker pool with a shared stop signal on `maxEmails` |
| Resumable state | Progress is stored in the key-value store keyed by a hash of the input, with throttled saves plus saves on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Streaming output | Every lead is pushed to the dataset immediately, so partial results survive an abort |
| Run summary | Logs pages fetched, blocked pages, retries and emails per page |

***

### How the Dev.to Email Scraper works

The pipeline behind the Dev.to Email Scraper is deliberately simple, which is why it runs quickly and is hard to break.

1. The Dev.to Email Scraper reads your input: keywords, location, email domains and limits.
2. It builds Google queries with the `site:` operator, for example `site:dev.to developer "@gmail.com"`.
3. It fetches Google result pages asynchronously through the Apify GOOGLE_SERP proxy using `aiohttp`.
4. It parses each result block structurally, finding the `<h3>` title and the smallest block around it.
5. It extracts emails from the block text with a domain-filtered regex.
6. It deduplicates globally and pushes each lead straight to the Apify dataset.

#### Why query expansion matters for developer writer outreach

Google caps a single query at roughly 300 results, so one query has a hard ceiling no matter how many pages you allow.

Query expansion is how the Dev.to Email Scraper gets past it: each keyword is combined with each email domain in several phrasings, and every variant carries its own result budget.

The default `queryModifiers` are `email`, `contact`, `maintainer`, `author` and `support` - the words that sit next to an address in a DEV bio or an article sign-off.

#### What the Dev.to Email Scraper does not do

It does not log into DEV, use the Forem or DEV API, render JavaScript, read reactions or private messages, or reach anything that is not already public in Google's index.

It is an independent Apify Actor and is not affiliated with, supported by or endorsed by DEV Community or Forem.

***

### Dev.to Email Scraper input fields

Every field the Dev.to Email Scraper accepts is optional except `keywords`. Defaults are exactly those shipped in the Actor's input schema.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["developer", "engineer"]` | Search terms describing the DEV Community accounts you want (topic, stack, role) |
| `location` | string | `""` | Optional location phrase added to every query |
| `customDomains` | array | `["@gmail.com", "@yahoo.com"]` | Only emails on these domains are kept; the leading `@` is optional |
| `maxEmails` | integer 1-10000 | `20` | Stop after this many unique emails |
| `countryCode` | string | `""` | Two-letter country for the search proxy (US, GB, DE...) |
| `expandQueries` | boolean | `true` | Search each keyword x domain pair in several phrasings |
| `queryModifiers` | array | `["email", "contact", "maintainer", "author", "support"]` | Extra words combined with each keyword when expansion is on |
| `maxPagesPerQuery` | integer 1-50 | `30` | Page cap per query |
| `maxConcurrency` | integer 1-20 | `5` | Parallel queries |

#### Example Dev.to Email Scraper input

```json
{
  "keywords": ["typescript tutorial", "devops engineer", "technical writer"],
  "location": "Toronto",
  "customDomains": ["@gmail.com", "@hey.com"],
  "maxEmails": 500,
  "countryCode": "CA",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "maintainer", "author", "support"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

#### Tuning the Dev.to Email Scraper for better yield

Topic language beats role language in the Dev.to Email Scraper, because DEV articles are titled by subject. `typescript generics`, `docker compose`, `postgres migration` and `career switch to devops` outperform a plain `engineer`.

Series and tutorial words help too. Adding `tutorial`, `guide` or `part 2` to a keyword pulls long-form authors rather than one-off commenters.

Leave `expandQueries` on. Turning it off gives one query per keyword and domain, which is faster but caps out quickly.

***

### Dev.to Email Scraper output fields

Every dataset item the Dev.to Email Scraper produces carries all 14 fields below. Fields are never dropped; they are empty or `null` when Google did not expose the value.

| Field | Meaning |
|---|---|
| `network` | Platform name |
| `keyword` | The keyword that produced the lead |
| `query` | The exact Google query used |
| `title` | Raw result title |
| `accountName` | Account label Google prints (handle, display name, or organisation) |
| `fullName` | Display name parsed from a profile-style title; empty for article titles |
| `username` | URL-safe DEV handle when one is exposed; otherwise `null` |
| `profileUrl` | Canonical `https://dev.to/{username}` URL when a handle is known; otherwise empty |
| `url` | Direct platform link when exposed, else the profile URL |
| `description` | Bio or article snippet, cleaned of labels and engagement counters |
| `email` | Lower-cased email address |
| `emailDomain` | The matched domain, for example `@gmail.com` |
| `possiblyTruncated` | `true` when Google's snippet ellipsis touched the email - verify before sending |
| `foundAt` | ISO 8601 UTC timestamp |

#### Example Dev.to Email Scraper output

```json
[
  {
    "network": "DEV Community",
    "keyword": "typescript tutorial",
    "query": "site:dev.to typescript tutorial contact \"@gmail.com\"",
    "title": "Typed API clients without the boilerplate - DEV Community",
    "accountName": "hannah-oduya",
    "fullName": "",
    "username": "hannah-oduya",
    "profileUrl": "https://dev.to/hannah-oduya",
    "url": "https://dev.to/hannah-oduya/typed-api-clients-without-the-boilerplate-3ab1",
    "description": "Part two of the TypeScript series. Consulting and workshops: hannah.oduya.dev@gmail.com",
    "email": "hannah.oduya.dev@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:14:22.481Z"
  },
  {
    "network": "DEV Community",
    "keyword": "devops engineer",
    "query": "site:dev.to intitle:\"devops engineer\" email \"@hey.com\" \"Toronto\"",
    "title": "Building a boring CI pipeline - DEV Community",
    "accountName": "Riley Chen",
    "fullName": "",
    "username": null,
    "profileUrl": "",
    "url": "https://dev.to/building-a-boring-ci-pipeline-49hd",
    "description": "Platform engineer in Toronto. Notes on CI reliability. Reach out at riley.chen.ops@hey ...",
    "email": "riley.chen.ops@hey.com",
    "emailDomain": "@hey.com",
    "possiblyTruncated": true,
    "foundAt": "2026-08-31T09:14:29.113Z"
  },
  {
    "network": "DEV Community",
    "keyword": "technical writer",
    "query": "site:dev.to technical writer author \"@gmail.com\"",
    "title": "Ines Duarte - DEV Community",
    "accountName": "inesduarte",
    "fullName": "Ines Duarte",
    "username": "inesduarte",
    "profileUrl": "https://dev.to/inesduarte",
    "url": "https://dev.to/inesduarte",
    "description": "Technical writer and developer advocate. Docs, tutorials and DevRel. Email: ines.duarte.writes@gmail.com",
    "email": "ines.duarte.writes@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:15:03.902Z"
  }
]
```

The second row is the honest case for the Dev.to Email Scraper: Google printed a display name without a handle, so `username` is `null` and `profileUrl` is empty. The row is still a lead, with `email`, `url` and `description` intact.

***

### Use cases for the Dev.to Email Scraper

| Use case | How the Dev.to Email Scraper helps |
|---|---|
| DevRel launch lists | Build a contact list of writers already publishing on your product's subject area |
| Technical content recruiting | Find authors who can write documentation, tutorials or a guest series |
| Developer tool marketing | Reach practitioners writing about the problem your tool solves |
| Guest post and syndication | Approach authors about cross-posting or a joint series |
| Sponsorship and newsletter placement | Contact writers with an established audience in a technical niche |
| Speaker sourcing | Shortlist meetup and conference speakers who already explain the topic well in writing |
| Community programme recruitment | Invite candidates to an ambassador, champions or beta programme |
| Ecosystem research | Measure how many authors in a topic publish a public contact channel at all |

#### Reaching DEV writers well

Writers on DEV notice generic outreach immediately, and often write about it, so treat Dev.to Email Scraper rows as a reading list first. Open `url`, name the article, and be explicit about what you are asking for.

When `username` resolves, `profileUrl` gives you the author's full posting history in one click, which is usually enough to judge fit before writing.

#### Covering the wider developer-writing footprint

Most developer writers publish in more than one place. Pair the Dev.to Email Scraper with the [Hashnode Email Scraper](https://apify.com/neuro-scraper/hashnode-email-scraper) for personal blogs, and with the [GitHub Email Scraper](https://apify.com/leads-scraper/github-email-scraper) to see the projects behind the posts.

***

### Expected results from the Dev.to Email Scraper

In live test runs against Google, roughly **7 out of 10 parsed DEV Community results carried an account identity** - a handle, a display name, or both.

That is a solid ratio for the Dev.to Email Scraper. Article URLs are shaped `dev.to/{username}/{slug}`, which resolves a handle well, but some indexed results surface only a display name in the title and no handle in the URL.

Dev.to Email Scraper rows without a handle still carry `email`, `emailDomain`, `url`, `description` and `query`. Volume always depends on your keywords, domains and location - no yield is guaranteed.

***

### Limitations of the Dev.to Email Scraper

Read this before planning a campaign around Dev.to Email Scraper output.

- **Publicly indexed emails only.** The Dev.to Email Scraper finds an address only when it is already visible in Google's index. Addresses shared only in comments Google has not indexed, or behind DEV's messaging, are out of reach.
- **No DEV or Forem API.** Article bodies, reactions and follower data are never read through an API. Only Google result titles and snippets are parsed.
- **Google's ~300-result cap.** A single query returns roughly 300 results maximum, which is exactly why `expandQueries` exists and why turning it off reduces volume.
- **`possiblyTruncated`.** When this is `true`, Google's snippet ellipsis touched the email and it may be cut off. Verify those rows before sending anything.
- **`username` and `profileUrl` can be empty.** They are populated only when DEV exposes a handle in the result. Some titles print only a display name, leaving `accountName` filled but `username` `null`.
- **Apify GOOGLE_SERP proxy required.** The Actor cannot run without Apify proxy credentials.
- **Free plan cap.** Free Apify plans are limited to 100 emails per run. Paid plans are uncapped.
- **Variable results.** Output depends on keywords, domains, location and Google's index, which changes over time. Two runs a month apart will not be identical.

***

### Responsible use

Addresses in DEV bios and articles are published for correspondence about the writing - questions, corrections, speaking invitations and collaboration. Treat them that way.

If you contact people in the EU or UK, GDPR applies: have a lawful basis, identify yourself, say where you found the address, and honour opt-outs immediately. Respect DEV Community norms and any stated preference such as "no recruiters" or "no sponsored posts".

DEV is a community with a long memory and a publishing platform attached. Relevance and brevity are not just polite here, they are self-interested.

***

### Dev.to Email Scraper FAQ

#### Does the Dev.to Email Scraper use the DEV or Forem API?

No. It parses Google search results for pages on `dev.to` that Google has already indexed. There is no API call, no login and no direct article fetch.

#### Does it need a DEV account?

No. There is no authentication, no browser, no JavaScript rendering and no cookies. The only credential required is your Apify account's GOOGLE_SERP proxy access.

#### Where do the emails the Dev.to Email Scraper returns come from?

From the text Google prints in result titles and snippets - profile bios, article sign-offs, series introductions and organisation pages that expose an address publicly.

#### Why does `network` say `DEV Community` rather than `Dev.to`?

Because that is the platform's own name, and it is how Google most often labels the site in a result block. The Actor's own name still uses the familiar `dev.to` domain.

#### How many emails can the Dev.to Email Scraper return?

`maxEmails` accepts 1 to 10000 and defaults to 20. Free Apify plans are capped at 100 emails per run; paid plans are uncapped. Volume depends on your keywords and domains.

#### Why is `username` sometimes `null`?

Because Google did not expose a DEV handle for that result - usually a title that prints only a display name. The row still carries `email`, `accountName`, `url` and `description`.

#### What does `possiblyTruncated: true` mean?

Google's snippet ellipsis touched the email, so the address may be incomplete. Verify those rows before you use them.

#### Can I restrict the Dev.to Email Scraper to company domains?

Yes. Put the domains you want in `customDomains`, for example `["@company.com", "@example.dev"]`. Only emails ending in those domains are kept, and the leading `@` is optional.

#### Does it handle obfuscated addresses like `name [at] gmail [dot] com`?

Yes. The extractor normalises `[at]`, `(at)`, spaced `@`, spaced `.com`, zero-width characters and the full-width `＠`, and it filters placeholders such as `test@` and `yourname@`.

#### Can I target writers in one city?

Set `location` to the city and `countryCode` to a two-letter code such as `US`, `GB` or `CA`. The location phrase is appended to every query and the code steers the search proxy.

#### What happens if a Dev.to Email Scraper run is interrupted?

Progress is saved in the key-value store keyed by a hash of your input, with saves on `PERSIST_STATE`, `MIGRATING` and `ABORTING`. Leads are pushed to the dataset as they are found, so nothing already collected is lost.

#### Is the Dev.to Email Scraper affiliated with DEV Community?

No. It is an independent Apify Actor, and it is not supported, endorsed or affiliated with DEV Community or Forem.

***

### Related Actors

The Dev.to Email Scraper belongs to a Developer & Technology family of Apify Actors that all work the same way on different platforms. Run several to cover an ecosystem instead of a single site.

| Actor | What it collects |
|---|---|
| [DEV Community Email and Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-email-and-phone-number-scraper) | Emails and phone numbers from DEV Community |
| [DEV Community Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-phone-number-scraper) | Public phone numbers from DEV Community |
| [App Store Email Scraper](https://apify.com/leads-scraper/app-store-email-scraper) | Public contact emails from App Store |
| [Atlassian Marketplace Email Scraper](https://apify.com/leads-scraper/atlassian-marketplace-email-scraper) | Public contact emails from Atlassian Marketplace |
| [Bitbucket Email Scraper](https://apify.com/neuro-scraper/bitbucket-email-scraper) | Public contact emails from Bitbucket |
| [Chrome Web Store Email Scraper](https://apify.com/leads-scraper/chrome-web-store-email-scraper) | Public contact emails from Chrome Web Store |
| [CodePen Email Scraper](https://apify.com/neuro-scraper/codepen-email-scraper) | Public contact emails from CodePen |
| [Confluence Email Scraper](https://apify.com/neuro-scraper/confluence-email-scraper) | Public contact emails from Confluence |
| [Docker Hub Email Scraper](https://apify.com/neuro-scraper/docker-hub-email-scraper) | Public contact emails from Docker Hub |
| [Figma Community Email Scraper](https://apify.com/neuro-scraper/figma-community-email-scraper) | Public contact emails from Figma Community |
| [Firefox Add-ons Email Scraper](https://apify.com/neuro-scraper/firefox-add-ons-email-scraper) | Public contact emails from Firefox Add-ons |
| [GitHub Email Scraper](https://apify.com/leads-scraper/github-email-scraper) | Public contact emails from GitHub |
| [GitLab Email Scraper](https://apify.com/neuro-scraper/gitlab-email-scraper) | Public contact emails from GitLab |
| [Google Play Email Scraper](https://apify.com/leads-scraper/google-play-email-scraper) | Public contact emails from Google Play |
| [Hashnode Email Scraper](https://apify.com/neuro-scraper/hashnode-email-scraper) | Public contact emails from Hashnode |
| [HubSpot Marketplace Email Scraper](https://apify.com/leads-scraper/hubspot-marketplace-email-scraper) | Public contact emails from HubSpot Marketplace |
| [Hugging Face Email Scraper](https://apify.com/leads-scraper/hugging-face-email-scraper) | Public contact emails from Hugging Face |
| [Jira Email Scraper](https://apify.com/neuro-scraper/jira-email-scraper) | Public contact emails from Jira |
| [Maven Central Email Scraper](https://apify.com/neuro-scraper/maven-central-email-scraper) | Public contact emails from Maven Central |
| [Microsoft AppSource Email Scraper](https://apify.com/neuro-scraper/microsoft-appsource-email-scraper) | Public contact emails from Microsoft AppSource |
| [Salesforce AppExchange Email Scraper](https://apify.com/leads-scraper/salesforce-appexchange-email-scraper) | Public contact emails from Salesforce AppExchange |
| [Shopify App Store Email Scraper](https://apify.com/leads-scraper/shopify-app-store-email-scraper) | Public contact emails from Shopify App Store |
| [Slack App Directory Email Scraper](https://apify.com/leads-scraper/slack-app-directory-email-scraper) | Public contact emails from Slack App Directory |
| [SourceForge Email Scraper](https://apify.com/leads-scraper/sourceforge-email-scraper) | Public contact emails from SourceForge |
| [Stack Overflow Email Scraper](https://apify.com/leads-scraper/stack-overflow-email-scraper) | Public contact emails from Stack Overflow |
| [Unity Asset Store Email Scraper](https://apify.com/leads-scraper/unity-asset-store-email-scraper) | Public contact emails from Unity Asset Store |
| [Unreal Engine Marketplace Email Scraper](https://apify.com/leads-scraper/unreal-engine-marketplace-email-scraper) | Public contact emails from Unreal Engine Marketplace |
| [WordPress Plugin Directory Email Scraper](https://apify.com/neuro-scraper/wordpress-plugin-directory-email-scraper) | Public contact emails from WordPress Plugin Directory |
| [WordPress Theme Directory Email Scraper](https://apify.com/leads-scraper/wordpress-theme-directory-email-scraper) | Public contact emails from WordPress Theme Directory |
| [Zapier App Directory Email Scraper](https://apify.com/leads-scraper/zapier-app-directory-email-scraper) | Public contact emails from Zapier App Directory |
| [App Store Email and Phone Number Scraper](https://apify.com/leads-scraper/app-store-email-and-phone-number-scraper) | Emails and phone numbers from App Store |
| [Atlassian Marketplace Email and Phone Number Scraper](https://apify.com/neuro-scraper/atlassian-marketplace-email-and-phone-number-scraper) | Emails and phone numbers from Atlassian Marketplace |
| [Bitbucket Email and Phone Number Scraper](https://apify.com/neuro-scraper/bitbucket-email-and-phone-number-scraper) | Emails and phone numbers from Bitbucket |
| [Chrome Web Store Email and Phone Number Scraper](https://apify.com/neuro-scraper/chrome-web-store-email-and-phone-number-scraper) | Emails and phone numbers from Chrome Web Store |
| [CodePen Email and Phone Number Scraper](https://apify.com/neuro-scraper/codepen-email-and-phone-number-scraper) | Emails and phone numbers from CodePen |
| [Confluence Email and Phone Number Scraper](https://apify.com/neuro-scraper/confluence-email-and-phone-number-scraper) | Emails and phone numbers from Confluence |
| [Docker Hub Email and Phone Number Scraper](https://apify.com/neuro-scraper/docker-hub-email-and-phone-number-scraper) | Emails and phone numbers from Docker Hub |
| [Figma Community Email and Phone Number Scraper](https://apify.com/neuro-scraper/figma-community-email-and-phone-number-scraper) | Emails and phone numbers from Figma Community |
| [Firefox Add-ons Email and Phone Number Scraper](https://apify.com/neuro-scraper/firefox-add-ons-email-and-phone-number-scraper) | Emails and phone numbers from Firefox Add-ons |
| [GitHub Email and Phone Number Scraper](https://apify.com/leads-scraper/github-email-and-phone-number-scraper) | Emails and phone numbers from GitHub |
| [GitLab Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-email-and-phone-number-scraper) | Emails and phone numbers from GitLab |
| [Google Play Email and Phone Number Scraper](https://apify.com/leads-scraper/google-play-email-and-phone-number-scraper) | Emails and phone numbers from Google Play |

### Leave a review

If the Dev.to Email Scraper saved you time, please leave a star rating and a short review on
the Actor page.

Reviews are how other buyers judge whether a tool works, and they tell us which features to
build next.

If something did not work, email <neurodata.apify@gmail.com>
instead - bugs get fixed faster than they get complained about.

### Support

Questions, a bug, or a custom build of the Dev.to Email Scraper for your own domain list? Email **neurodata.apify@gmail.com** and we will get back to you.

# Actor input Schema

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

Search terms describing the DEV Community accounts you want (niche, job title, industry).

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

Optional location phrase added to every query (e.g. "New York").

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

Only emails ending with one of these domains are collected. With or without the leading @. Each domain is searched separately, so more domains means more results but a longer run - remove some for a faster, narrower search, or add your own (e.g. @company.com).

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

Stop once this many unique emails have been collected.

## `countryCode` (type: `string`):

Two-letter country code for the search proxy (e.g. US, GB, DE). Empty for any.

## `expandQueries` (type: `boolean`):

Search each keyword x domain pair with several phrasings. Recommended - Google caps a single query at ~300 results.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when Expand queries is on. Tuned for DEV Community.

## `maxPagesPerQuery` (type: `integer`):

Google rarely returns more than ~30 pages for one query.

## `maxConcurrency` (type: `integer`):

How many queries run in parallel.

## Actor input object example

```json
{
  "keywords": [
    "developer",
    "engineer"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "countryCode": "",
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "maintainer",
    "author",
    "support"
  ],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Records produced by Dev.to Email Scraper, stored in the run's default dataset.

# 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": [
        "developer",
        "engineer"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "maintainer",
        "author",
        "support"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-scraper/dev-to-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": [
        "developer",
        "engineer",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "maintainer",
        "author",
        "support",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-scraper/dev-to-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": [
    "developer",
    "engineer"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "maintainer",
    "author",
    "support"
  ]
}' |
apify call neuro-scraper/dev-to-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuro-scraper/dev-to-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/TVSFlpzgEAwap779E/builds/aL7mB8ZjoOLhSZaqf/openapi.json