# Instagram Profile Email Scraper (`neuro-data/instagram-profile-email-scraper`) Actor

Instagram Profile Email Scraper SD - Instagram Profile Email Scraper is a powerful tool that extracts public bio emails, names, bios, avatars, external links and follower, following and post counts from Instagram profile URLs or usernames - public profiles only, no login, no private data.

- **URL**: https://apify.com/neuro-data/instagram-profile-email-scraper.md
- **Developed by:** [Neuro Data](https://apify.com/neuro-data) (community)
- **Categories:**
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Instagram Profile Email Scraper

**Instagram Profile Email Scraper** turns keywords, or a list of Instagram profile URLs and handles, into a clean dataset of public contact emails, bios, follower counts and avatars — an Instagram email finder and Instagram profile scraper in one Actor.

There are two ways in. Give this Instagram profile scraper **keywords** and it looks for accounts that publish a contact address, then enriches every one it finds. Give it **profile URLs or usernames** and it goes straight to the accounts you already know.

A keyword run does not return accounts that merely match a word. The Instagram Profile Email Scraper targets pages that publish an address beside it, so most rows arrive with an email attached. Both inputs can be combined in one run.

There is no login, no cookies, no session token, no private or official API, and no browser or JavaScript rendering. Only public profile data is collected by the Instagram Profile Email Scraper.

One honest note up front, because it shapes your runs. Instagram rate-limits shared proxy pools, so some profiles in a large run come back blocked. Lower `maxConcurrency` and re-run those rows.

That is the normal rhythm for any Instagram email scraper working from a shared residential pool without a login.

***

### What the Instagram Profile Email Scraper does

The Instagram Profile Email Scraper both finds the audience and enriches it. It runs in two phases, and the order is the whole design.

**Phase 1 — Google harvest, on the GOOGLE\_SERP proxy.** Given keywords, the Instagram Profile Email Scraper searches Google with an email dork — `site:instagram.com wedding photographer "@gmail.com"` — expanded across keyword x modifier x address domain, paging up to `maxPagesPerKeyword` per query.

Each result block yields the account handle **and** the address published on that page, in one request. Google rarely prints the target URL now, so the handle comes from the site label, the breadcrumb, or a `Name (@handle)` title.

This is where the volume and most of the addresses come from. Asking Google for pages that already carry an address is one request per ten accounts; fetching every profile hoping for one is a request each, and most bios have none.

**Phase 2 — profile enrichment, on the RESIDENTIAL proxy.** Every account the Instagram Profile Email Scraper finds is then fetched for its real profile data — followers, avatar, bio, verified flag — and merged into one row with the address from phase 1. Accounts you supply skip phase 1 and start here.

Search for an Instagram email scraper and you will find tools that promise to invent contacts. The Instagram Profile Email Scraper does not. It is an Instagram contact scraper for addresses creators chose to publish.

In order:

1. Reads `keywords` and/or `profileUrls` and `usernames`, plus your limits and filters.
2. Runs phase 1 and queues every handle harvested.
3. Normalises every target to one canonical URL — `https://www.instagram.com/username/`. A bare handle, an `@handle` and a full URL resolve to the same target, and duplicates are dropped.
4. Fetches each profile through the Apify **residential** proxy, several in parallel, with a fresh exit IP on every retry. The first attempt sends a full browser header set, as a browser asks for a public page; a retry falls back to a plainer one.
5. Parses the response with a regex-first cascade, each step filling only what the previous could not.
6. Extracts any further emails from the bio, display name and external URL, then pushes one row per profile.

The Instagram Profile Email Scraper cascade runs a regex battery against the raw HTML matching key names directly (`"biography"`, `"follower_count"`, `"is_verified"`), then the Instagram-specific parser, then Open Graph and link-preview meta tags.

Matching key names rather than following an object path is a deliberate design choice. Platforms move those objects between releases; the key names survive.

***

### Why choose this Instagram Profile Email Scraper

Most tools sold as an Instagram bio email extractor either need your logged-in session or hand you raw HTML. The Instagram Profile Email Scraper does neither.

What separates a usable Instagram email finder from a noisy one is the filtering, not the fetching. Here is what this Instagram email scraper does with the text.

**Obfuscation-aware hygiene.** Creators hide addresses on purpose. The Instagram Profile Email Scraper undoes `[at]`, `(dot)`, spaced `a @ b`, zero-width characters and full-width `＠` before matching.

**Boundary-correct domains.** `@gmail.com` will not match inside `@gmail.company`, so your CRM does not fill with the malformed addresses a naive Instagram email extractor produces.

**Junk filtered, role addresses kept.** Placeholder locals such as `email@`, `yourname@` and `noreply@` are dropped, as are prose words like `the@`. Real role addresses — `hi@`, `hey@`, `hello@` — are kept, because that is what creators publish for partnerships.

**Every row saved as it lands.** Results stream: each account goes to profile enrichment the moment the Google search finds it, so the first rows are saved seconds into a run and keep arriving while the search continues.

Each saved row is logged as it is written, naming the handle, address and counts found, and every row carries the same field set whether it came from a keyword or a URL you supplied.

***

### How to use the Instagram Profile Email Scraper step by step

Running the Instagram Profile Email Scraper takes about a minute of setup.

1. **Open the Actor** on Apify and click **Try for free** or **Start**.
2. **Start from a keyword.** Type a niche, job title or industry into *Search keywords* — `wedding photographer`, `manager` — and the harvest finds accounts in it that publish an address. Add a *Location*, or raise *Pages per keyword* to find more.
3. **Or paste your targets** into *Instagram profile URLs*. Full URLs, bare handles and `@handles` all work, and every list is combined and de-duplicated.
4. **Set *Email domains*** to steer which address domains the search asks for, and to filter what is kept. Empty means the common free-mail providers.
5. **Toggle *Only save profiles that have an email*** if a row without contact details is worthless to you.
6. **Set *Max profiles*** to cap the run.
7. **Set *Max concurrency* conservatively.** The default is 10, and the range is 1–30. Because Instagram rate-limits shared proxy pools, lowering this is the most effective change when you see blocks.
8. **Leave the proxy on RESIDENTIAL.** Profile pages block datacenter IPs. Add a *Proxy country* only if you need a specific region.
9. **Click Save & Start.** Rows appear in the dataset as they land.
10. **Re-run the blocked rows** with lower concurrency.
11. **Export** to CSV, JSON, Excel or XML, or pull the dataset into your CRM through the Apify API.

At the end of an Instagram Profile Email Scraper run the log reports counts of ok, blocked, not found and errors, so you know what to re-run and how to tune concurrency next time.

***

### Input schema

Every field the Instagram Profile Email Scraper accepts, nothing invented:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array | prefilled with example terms | Search terms. The Actor finds matching Instagram accounts and scrapes each one. |
| `location` | string | `""` | Added to every keyword search, e.g. `New York`. Keyword search only. |
| `maxPagesPerKeyword` | integer 1–30 | `5` | Google results pages read per query. Raise to find more accounts. Keyword search only. |
| `expandQueries` | boolean | `true` | Search each keyword in several phrasings (keyword + "email", + "contact", …). Keyword search only. |
| `queryModifiers` | array | `email`, `contact`, `business inquiries`, `collab`, `booking`, `dm` | Extra words combined with each keyword when expansion is on. |
| `profileUrls` | array | `[]` | Full Instagram profile URLs. Bare usernames also accepted. |
| `usernames` | array | `[]` | Handles without the URL. Combined with the list above. |
| `customDomains` | array | `[]` | Address domains the search asks Google for, and a filter on the results. Empty searches the common free-mail providers and keeps every address found. |
| `onlyWithEmail` | boolean | `false` | Skip profiles whose public bio contains no address. |
| `maxProfiles` | integer 1–100000 | `100` | Stop after this many profiles are saved. |
| `maxConcurrency` | integer 1–30 | `10` | How many profiles are fetched in parallel, and how many Google searches run at once. Higher is faster; lower it if rows come back blocked. |
| `proxyGroup` | select | `RESIDENTIAL` | `RESIDENTIAL`, `BUYPROXIES94952` or `UNBLOCKER`. |
| `countryCode` | string | `""` | Two-letter proxy country (US, GB, DE…). Empty for any. |

That is the complete list — no data-source switch, no hidden options. Supply at least one of `keywords`, `profileUrls` or `usernames`; with none of them the Instagram Profile Email Scraper stops and tells you to add one.

#### Input examples for the Instagram Profile Email Scraper

Starting from keywords, with no list of accounts yet:

```json
{
  "keywords": ["wedding photographer", "florist"],
  "location": "Austin",
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "onlyWithEmail": false,
  "maxProfiles": 500,
  "maxConcurrency": 3,
  "proxyGroup": "RESIDENTIAL"
}
```

Starting from accounts you already know, or mixing both ways in one run:

```json
{
  "keywords": ["home baker"],
  "profileUrls": ["https://www.instagram.com/juliabakes/", "@paintwithlee"],
  "usernames": ["treklinescarl"],
  "onlyWithEmail": true,
  "maxProfiles": 500,
  "maxConcurrency": 3,
  "countryCode": "US"
}
```

Note `maxConcurrency: 3`. On a long Instagram lead generation run, going slower usually returns more rows than going wide.

***

### Finding accounts from a keyword

Keyword search in the Instagram Profile Email Scraper is a real search, not a filter over URLs you supplied. Give this Instagram email finder a niche, job title or industry and the harvest looks for accounts in it that publish a contact address.

With `expandQueries` on, each keyword is combined with every entry in `queryModifiers` and every address domain, and each combination is paged separately. *Location* narrows the search; `maxPagesPerKeyword` sets how deep each query is read.

The harvest runs on the Apify **GOOGLE\_SERP** proxy, the profile fetch on the **RESIDENTIAL** proxy. Neither group can do the other's job — Google is reachable only through GOOGLE\_SERP, and Instagram needs residential exit IPs.

Every account the Instagram Profile Email Scraper finds this way is enriched exactly like one you pasted in yourself. Accounts you supplied are queued first, then whatever the harvest discovers, and `keyword` and `query` record which search produced each row.

***

### Output schema

Every dataset row from the Instagram Profile Email Scraper has all of these fields:

| Field | Meaning |
|---|---|
| `success` | True when the profile was fetched and parsed, **or** an address was found for the account. A blocked fetch still yields a usable row when the harvest gave an address. |
| `network` | Platform name |
| `dataSource` | Which path produced the profile data — always `page` here |
| `keyword` | The keyword that found this account, or `null` for a supplied URL |
| `query` | The exact Google query that found it, or `null` |
| `description` | The result snippet Google showed, cleaned of labels and counters |
| `profileUrl` | The canonical profile URL that was requested |
| `url` | The URL actually returned, after redirects |
| `username` | Handle |
| `fullName` | Display/real name as published |
| `displayName` | Handle or title the platform shows |
| `email` | First public email found, or `null` |
| `emails` | Every public email found, deduplicated |
| `emailSource` | Where the addresses came from: `search` (the Google harvest), `bio` (the profile), `bio+search`, or `null`. `search` is the common value on a keyword run |
| `bio` | Public bio / description text |
| `followersCount` | Followers, when published |
| `followingCount` | Accounts followed, when published |
| `postsCount` | Posts, when published |
| `isVerified` | Verified badge, when published |
| `isPrivate` | Private account, when published |
| `avatarUrl` | Profile picture URL |
| `userId` | Numeric/string platform id, when published |
| `error` | Why a row failed, or `null` |
| `scrapedAt` | ISO 8601 UTC timestamp |

A field Instagram does not publish is not part of the row at all. Normal, and not hidden.

#### Output example from the Instagram Profile Email Scraper

A realistic row from a keyword run:

```json
{
  "success": true,
  "network": "Instagram",
  "dataSource": "page",
  "keyword": "home baker",
  "query": "site:instagram.com home baker email \"@gmail.com\"",
  "description": "Home baker in Austin. New recipe every Friday. Collabs: hello@juliabakes.co",
  "profileUrl": "https://www.instagram.com/juliabakes/",
  "url": "https://www.instagram.com/juliabakes/",
  "username": "juliabakes",
  "fullName": "Julia Baker",
  "displayName": "juliabakes",
  "email": "hello@juliabakes.co",
  "emails": ["hello@juliabakes.co"],
  "emailSource": "bio+search",
  "bio": "Home baker in Austin 🍰 new recipe every Friday | collabs: hello (at) juliabakes.co",
  "followersCount": 84210,
  "followingCount": 913,
  "postsCount": 1204,
  "isVerified": false,
  "isPrivate": false,
  "avatarUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/4b7c1e9a.jpg",
  "userId": "1794456321",
  "error": null,
  "scrapedAt": "2026-08-31T09:41:12.508Z"
}
```

Notice that `keyword` and `query` show which search found the account, and `description` is the snippet Google printed beside it.

The bio wrote the address as `hello (at) juliabakes.co`, normalised by the Instagram Profile Email Scraper before matching. And `likesCount` is `null` while `secUid` is `""`, because Instagram publishes neither.

***

### Use cases for the Instagram Profile Email Scraper

**Influencer marketing outreach.** Search a niche keyword and the Instagram Profile Email Scraper returns creators who publish a contact address, already enriched — the classic Instagram creator email scraper job.

**Agency prospecting.** Run a keyword for the vertical you sell into and build a pipeline of accounts publishing a business email: a straightforward Instagram lead generation workflow.

**UGC sourcing.** Use it as an Instagram contact scraper to find creators whose audience size and posting volume match your budget, then reach them directly.

**Lead enrichment for an existing CRM.** You already have handles on your contact records. Point the Instagram Profile Email Scraper at them and it fills the empty email column.

**Local business prospecting.** Many small businesses run their storefront on Instagram and publish a booking address, which makes this a clean B2B discovery source.

**Talent management.** Track roster handles, follower count and contact route in one dataset, and re-run monthly to keep it fresh.

**Competitive and market research.** Measure audience size and posting volume across a peer set — an Instagram profile scraper use case with nothing to do with email.

**Affiliate and partnership recruiting.** Run it as an Instagram bio email extractor across a shortlist and hand sales a ready contact list.

***

### Limitations of the Instagram Profile Email Scraper

Read these before you run. Honest constraints of the Instagram Profile Email Scraper:

**Rate limiting is the main one.** Instagram rate-limits shared proxy pools, so some profiles in a large run come back blocked. Lower `maxConcurrency` and re-run those rows. Expected behaviour, not a defect.

**Yield varies, and it is not a promise.** The Instagram Profile Email Scraper harvest asks for pages that publish an address, so most rows on a keyword run carry one. How many depends on the platform, the niche, and how many accounts in it publish an address at all.

A row is still returned when only profile data is available, with `email: null` — honest, not a failure. Addresses no longer come only from bios: the harvest and the profile are independent sources, and `emailSource` says which answered.

**The harvest needs the GOOGLE\_SERP proxy.** It is the only route to Google. A keywords-only run fails without that proxy group; a run that also has profile URLs logs a warning and carries on with those.

**Public data only.** No login, no cookies, no private or official API, no browser, no JavaScript rendering. Anything a signed-out visitor cannot see is out of reach.

**Private accounts stay private.** A private profile publishes almost nothing, so no Instagram email finder — this one included — returns a bio for it.

**Some fields come back empty.** `likesCount` and `secUid` are not published by Instagram, and any other field the page does not carry is returned as `null` or `""`.

**Retries help but do not eliminate blocks.** The Instagram Profile Email Scraper makes up to four attempts per page with exponential backoff and a fresh exit IP, and a redirect to a login page counts as rate limiting, not a missing profile. Some rows still fail.

**Free plan cap.** On a free Apify account an Instagram Profile Email Scraper run is capped at 100 profiles. Paid plans are uncapped by the Actor.

**Nothing is guaranteed.** Platforms change their markup. This Instagram bio email extractor is built to survive that, not to be immune to it.

***

### Pricing and run behaviour of the Instagram Profile Email Scraper

The Instagram Profile Email Scraper uses pay-per-event billing: `actor-start` once per run and `profile-scraped` for each saved row.

Instagram Profile Email Scraper runs are resumable. Progress is keyed to a hash of the input, so a migrated or restarted run continues instead of refetching profiles you paid for. Changing the input starts a clean run.

***

### FAQ

**How does keyword search work?**
In two phases. A Google harvest on the GOOGLE\_SERP proxy searches with an email dork — `site:instagram.com wedding photographer "@gmail.com"` — expanded across your keywords, `queryModifiers` and address domains, and each result returns a handle with the address published beside it. Every account found is then fetched on the RESIDENTIAL proxy for its profile data, and the two are merged into one row.

**Why does a row have `success: true` when the fetch was blocked?**
Because `success` now means the run produced something usable: the profile was fetched, or an address was found. A profile Instagram declined to serve still yields a row with the email from the harvest, and `error` records what happened.

**Do profile URLs and usernames still work?**
Yes, unchanged. Keywords are an additional way in, not a replacement, and both can be combined in one run — supplied accounts are queued first, then whatever the harvest discovers.

**Does it need my Instagram login, cookies or an API key?**
No. The Instagram Profile Email Scraper never logs in, never uses cookies or a session, and never touches a private or official API. It reads only public profile data.

**Why did some rows come back with `success: false`?**
Because neither route produced anything: the fetch was blocked and no address was found. Lower `maxConcurrency`, keep the proxy on `RESIDENTIAL`, and re-run them.

**What is a good `maxConcurrency` value?**
The default is 10, and the range is 1–30. If the run summary shows a lot of blocked rows, drop to 2 or 3 — slower and complete beats wide and patchy.

**Will it find an email that was never made public?**
No. This Instagram email finder reads public pages — bio, display name, external URL, plus what Google indexed. Addresses never published stay out of reach.

**What if a creator wrote their address as `name (at) domain (dot) com`?**
It is still matched. Obfuscation is undone before extraction, including `[at]`, `(dot)`, spaced `a @ b`, zero-width characters and full-width `＠`.

**Why are `likesCount` and `secUid` empty?**
Instagram does not publish a total like count, and `secUid` is TikTok's identifier. Both exist in every row for schema consistency across the family.

**How many profiles can one run process?**
Free Apify plans are capped at 100 profiles per run. On paid plans `maxProfiles` accepts up to 100000.

**Can I filter to only business domains?**
Yes. List them in `customDomains`. That both steers which domains the search asks Google for and keeps only addresses on them.

**Does it work as a general Instagram lead generation tool?**
Yes. Start from a keyword and the Instagram Profile Email Scraper harvest builds the list, then enrichment fills it in; or supply handles and it enriches those.

***

### Related Actors

| Actor | Link |
|---|---|
| Facebook Profile Email Scraper | https://apify.com/neuro-data/facebook-profile-email-scraper |
| TikTok Profile Email Scraper | https://apify.com/neuro-data/tiktok-profile-email-scraper |
| YouTube Profile Email Scraper | https://apify.com/neuro-data/youtube-profile-email-scraper |
| X Profile Email Scraper | https://apify.com/neuro-data/x-profile-email-scraper |
| Pinterest Profile Email Scraper | https://apify.com/neuro-data/pinterest-profile-email-scraper |
| Snapchat Profile Email Scraper | https://apify.com/neuro-data/snapchat-profile-email-scraper |
| Threads Profile Email Scraper | https://apify.com/neuro-data/threads-profile-email-scraper |
| Tumblr Profile Email Scraper | https://apify.com/neuro-data/tumblr-profile-email-scraper |
| Telegram Profile Email Scraper | https://apify.com/neuro-data/telegram-profile-email-scraper |
| Twitch Profile Email Scraper | https://apify.com/neuro-data/twitch-profile-email-scraper |
| Kick Profile Email Scraper | https://apify.com/neuro-data/kick-profile-email-scraper |
| Substack Profile Email Scraper | https://apify.com/neuro-data/substack-profile-email-scraper |
| Patreon Profile Email Scraper | https://apify.com/neuro-data/patreon-profile-email-scraper |
| Behance Profile Email Scraper | https://apify.com/neuro-data/behance-profile-email-scraper |
| Dribbble Profile Email Scraper | https://apify.com/neuro-data/dribbble-profile-email-scraper |
| DeviantArt Profile Email Scraper | https://apify.com/neuro-data/deviantart-profile-email-scraper |
| SoundCloud Profile Email Scraper | https://apify.com/neuro-data/soundcloud-profile-email-scraper |
| Mixcloud Profile Email Scraper | https://apify.com/neuro-data/mixcloud-profile-email-scraper |
| Mastodon Profile Email Scraper | https://apify.com/neuro-data/mastodon-profile-email-scraper |
| Bluesky Profile Email Scraper | https://apify.com/neuro-data/bluesky-profile-email-scraper |
| Linktree Profile Email Scraper | https://apify.com/neuro-data/linktree-profile-email-scraper |
| Gumroad Profile Email Scraper | https://apify.com/neuro-data/gumroad-profile-email-scraper |
| Buy Me a Coffee Profile Email Scraper | https://apify.com/neuro-data/buy-me-a-coffee-profile-email-scraper |
| GitHub Profile Email Scraper | https://apify.com/neuro-data/github-profile-email-scraper |
| GitLab Profile Email Scraper | https://apify.com/neuro-data/gitlab-profile-email-scraper |
| Hugging Face Profile Email Scraper | https://apify.com/neuro-data/hugging-face-profile-email-scraper |
| DEV Community Profile Email Scraper | https://apify.com/neuro-data/dev-to-profile-email-scraper |
| Hashnode Profile Email Scraper | https://apify.com/neuro-data/hashnode-profile-email-scraper |
| Flipboard Profile Email Scraper | https://apify.com/neuro-data/flipboard-profile-email-scraper |

***

### Support

Questions about the Instagram Profile Email Scraper, a bug report, or a custom Instagram lead generation build? Write to <neurodata.apify@gmail.com>.

Include your run ID and the input you used for a faster answer. Feature requests are welcome too.

You are responsible for how you use the data this Instagram profile scraper returns, including compliance with privacy and marketing law in your jurisdiction.

# Actor input Schema

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

Search terms - a niche, job title or industry. The Actor finds Instagram accounts matching each term, then scrapes every account it finds. Use this when you do not already have a list of accounts. You can combine keywords with the profile URLs below.

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

Added to every keyword search, e.g. `New York`. Leave empty to search everywhere. Only applies to keyword search.

## `profileUrls` (type: `array`):

Full Instagram profile URLs, e.g. `https://www.instagram.com/username/`. Bare usernames also work. Use this when you already know which accounts you want.

## `usernames` (type: `array`):

Instagram handles without the URL. Combined with the list above.

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

Domains the keyword search asks Google for, e.g. `@gmail.com`. Also filters results to these domains. Empty searches the common free-mail providers and keeps every address found.

## `onlyWithEmail` (type: `boolean`):

Skip profiles whose public bio contains no contact address.

## `maxProfiles` (type: `integer`):

Stop after this many profiles have been saved.

## `maxPagesPerKeyword` (type: `integer`):

How many Google results pages to read per search query. Raise it to find more accounts. Keyword search only.

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

Search each keyword in several phrasings (keyword + "email", + "contact", ...) to reach accounts a single query misses. Keyword search only.

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

Extra words combined with each keyword when query expansion is on. Leave empty to use the defaults for this platform.

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

How many profiles are fetched in parallel, and how many Google searches run at once. Raise it for speed, lower it if you see blocked rows.

## `proxyGroup` (type: `string`):

RESIDENTIAL is recommended. Profile pages block datacenter IPs.

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

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

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "profileUrls": [],
  "usernames": [],
  "customDomains": [],
  "onlyWithEmail": false,
  "maxProfiles": 100,
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "business inquiries",
    "collab",
    "booking",
    "dm"
  ],
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": ""
}
```

# Actor output Schema

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

Records produced by Instagram Profile 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "countryCode": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-data/instagram-profile-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",
    ],
    "location": "",
    "countryCode": "",
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-data/instagram-profile-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"
  ],
  "location": "",
  "countryCode": ""
}' |
apify call neuro-data/instagram-profile-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuro-data/instagram-profile-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/Xh2vEIk7PxFbClZ1V/builds/F56dX9wLA9cAb2vtF/openapi.json