# Jira Email Scraper (`neuro-scraper/jira-email-scraper`) Actor

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

- **URL**: https://apify.com/neuro-scraper/jira-email-scraper.md
- **Developed by:** [Neuro Scraper](https://apify.com/neuro-scraper) (community)
- **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

### Jira Email Scraper — public contact emails from indexed Atlassian sites

**Jira Email Scraper** collects publicly indexed contact emails that appear alongside Jira issue trackers, service desk portals and Atlassian project pages in Google's search index. You give it keywords, the email domains you care about and an optional location, and it returns a clean, deduplicated dataset of leads.

Before you run it, one honest caveat that shapes everything below: **most Jira sites are private; only public issue trackers and service desks are indexed, so expect modest volume.** This is a targeted Jira contact discovery tool, not a bulk list builder.

The Jira Email Scraper never logs in, never touches the Atlassian REST API and never opens a Jira site in a browser. Every field it returns comes from Google result blocks — titles, snippets and site labels — fetched through the Apify GOOGLE_SERP proxy.

Because Jira Cloud gives every customer their own subdomain (`acme.atlassian.net`), the Jira Email Scraper can recover that subdomain and use it as the `username`, then build a `profileUrl` from it. In measured runs this worked for 9 of 10 rows, which is unusually high for a Google-sourced dataset.

One thing to internalise early: on Jira the `accountName` is normally an **organisation**, not a person. You are finding the team behind a public service desk or issue tracker, not an individual's personal inbox.

#### Who the Jira Email Scraper is for

Agencies selling ITSM consulting, Atlassian solution partners, DevOps tooling vendors, recruiters hiring Jira administrators and researchers mapping public issue trackers all need the same thing: a shortlist of organisations that run a public Jira and publish a way to reach them.

The Jira Email Scraper builds that shortlist by keyword instead of by manual searching. If you also work across the wider Atlassian ecosystem, pair it with the [Confluence Email Scraper](https://apify.com/neuro-scraper/confluence-email-scraper) and the [Atlassian Marketplace Email Scraper](https://apify.com/leads-scraper/atlassian-marketplace-email-scraper).

### Key features of the Jira Email Scraper

Everything the Jira Email Scraper does is listed below. If a capability is not in this table, the Jira Email Scraper does not have it.

| Feature | What it does |
|---|---|
| Google `site:` targeting | Every query is scoped to `atlassian.net` and `atlassian.com`, so results stay on Jira and Atlassian pages |
| Subdomain handle recovery | Reads the customer subdomain from the indexed URL and stores it as `username` |
| Query expansion | Runs each keyword as a base query, a quoted phrase, an `intitle:` query and one variant per query modifier |
| Domain filtering | Keeps only emails ending in the domains you list, with boundary-correct matching |
| 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 |
| Global deduplication | One row per unique email address across every query and every page |
| Truncation flag | Marks a row `possiblyTruncated: true` when Google's snippet ellipsis touched the address |
| Structural parsing | Locates the `<h3>` title then the smallest surrounding block, instead of depending on Google's CSS class names |
| 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 |
| Resumable state | Progress is stored in the key-value store, keyed by a hash of your input, and saved on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Concurrency control | An `asyncio` worker pool with a shared stop signal on `maxEmails` |
| Streaming output | Each lead is pushed to the dataset immediately, so you can watch results arrive |

### How the Jira Email Scraper works

The pipeline is short and deliberately transparent. Understanding it tells you exactly why some rows are rich and others are sparse.

1. The Jira Email Scraper reads your input: keywords, location, email domains and limits.
2. It builds Google queries with the `site:` operator, for example `site:atlassian.net service desk "@gmail.com" "Berlin"`.
3. It fetches Google result pages asynchronously with `aiohttp` through the Apify GOOGLE_SERP proxy.
4. It parses each result block structurally — find the `<h3>`, then take the smallest block that contains it.
5. It extracts email addresses from the block text with a domain-filtered regular expression.
6. It deduplicates globally and pushes every new lead straight to the Apify dataset.

There is no browser, no JavaScript rendering, no authentication and no cookies anywhere in that list. That is the whole reason the Jira Email Scraper is cheap to run and why it only ever sees what Google already shows the public.

Query expansion exists because Google caps a single query at roughly 300 results. Running `project manager` as a base query, a quoted phrase, an `intitle:` query and five modifier variants reaches far more of the index than one query ever could.

Base queries always run first, so the highest-signal results land in your dataset before the long tail. If you set `maxEmails` low, you still get the best matches.

### Input fields

Every input field of the Jira Email Scraper is listed below exactly as defined in the Actor's input schema. Only `keywords` is required.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["project manager", "service desk"]` | Search terms describing the Jira accounts you want |
| `location` | string | `""` | Optional location phrase added to every query |
| `customDomains` | array | `["@gmail.com", "@yahoo.com"]` | Only emails on these domains are kept; the `@` 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 × domain pair in several phrasings |
| `queryModifiers` | array | `["email", "contact", "support", "admin", "service desk"]` | 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 |

The `queryModifiers` default is tuned for Jira specifically. Words like `service desk` and `admin` match how public Atlassian portals actually describe themselves, which is why the Jira Email Scraper ships with them rather than generic terms.

#### Example input for the Jira Email Scraper

```json
{
  "keywords": ["service desk", "IT support portal", "project manager"],
  "location": "Germany",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 200,
  "countryCode": "DE",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "support", "admin", "service desk"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

Start narrower than you think you need. Because public Jira instances are scarce, a focused keyword plus a well-chosen `countryCode` usually beats a broad sweep.

### Output fields

Every dataset item produced by the Jira Email Scraper carries all fourteen fields below. Nothing is omitted; fields with no value are empty or `null`.

| 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 — on Jira this is usually an organisation |
| `fullName` | Display name parsed from a profile-style title; empty for other result types |
| `username` | The Atlassian subdomain when Google exposes it; otherwise `null` |
| `profileUrl` | `https://{username}.atlassian.net/` when a subdomain is known; otherwise empty |
| `url` | Direct Jira link when exposed, else the profile URL |
| `description` | Snippet text, cleaned of labels and counters |
| `email` | Lower-cased email address |
| `emailDomain` | The matched domain, e.g. `@gmail.com` |
| `possiblyTruncated` | `true` when Google's snippet ellipsis touched the email — verify before sending |
| `foundAt` | ISO 8601 UTC timestamp |

#### Example output from the Jira Email Scraper

```json
[
  {
    "network": "Jira",
    "keyword": "service desk",
    "query": "site:atlassian.net service desk \"@gmail.com\" \"Germany\"",
    "title": "Service Desk - Acme Logistics - Jira",
    "accountName": "Acme Logistics",
    "fullName": "Acme Logistics",
    "username": "acme-logistics",
    "profileUrl": "https://acme-logistics.atlassian.net/",
    "url": "https://acme-logistics.atlassian.net/servicedesk/customer/portal/1",
    "description": "Raise a request with the Acme Logistics service desk. General enquiries: acme.helpdesk@gmail.com",
    "email": "acme.helpdesk@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:14:22Z"
  },
  {
    "network": "Jira",
    "keyword": "project manager",
    "query": "site:atlassian.net intitle:\"project manager\" \"@yahoo.com\"",
    "title": "Open issues - Northwind Community Projects",
    "accountName": "Northwind Community Projects",
    "fullName": "",
    "username": "northwind-community",
    "profileUrl": "https://northwind-community.atlassian.net/",
    "url": "https://northwind-community.atlassian.net/",
    "description": "Public issue tracker. Project coordination contact: northwind.pm@yahoo.com",
    "email": "northwind.pm@yahoo.com",
    "emailDomain": "@yahoo.com",
    "possiblyTruncated": true,
    "foundAt": "2026-08-31T09:16:05Z"
  }
]
```

Note the second row's `possiblyTruncated: true`. The Jira Email Scraper sets that flag when Google's ellipsis touched the address, so treat those rows as candidates to verify rather than confirmed contacts.

### Use cases for the Jira Email Scraper

| Use case | How the Jira Email Scraper helps |
|---|---|
| Atlassian partner prospecting | Find organisations running a public Jira and reach the team that maintains it |
| ITSM and DevOps tool sales | Target companies with a visible service desk workflow already in place |
| Recruiting Jira administrators | Surface organisations whose public trackers show active Jira operations |
| Migration and consulting outreach | Identify public issue trackers that may need cleanup, migration or training |
| Open-source project contact | Reach maintainers of community projects that host their tracker on Atlassian Cloud |
| Competitive and market research | Map which sectors publish public Jira portals, by keyword and country |
| Bug and security reporting | Locate the published contact channel for a public tracker |
| Data enrichment | Attach a public contact address to an organisation you already have in your CRM |

Across all of these, the honest framing matters. You are contacting a published organisational channel about something relevant to that organisation's Jira usage — not cold-blasting individuals.

Developer-tooling teams often run the Jira Email Scraper next to a code-hosting Actor such as the [GitHub Email Scraper](https://apify.com/leads-scraper/github-email-scraper) or the [Bitbucket Email Scraper](https://apify.com/neuro-scraper/bitbucket-email-scraper), then merge the datasets on `email`. The Jira Email Scraper supplies the operations side of that picture, and the repository Actors supply the engineering side.

### Tips to get more from the Jira Email Scraper

Use keywords that mirror the language of a public portal. `service desk`, `help centre`, `customer portal`, `bug tracker` and `support request` all appear in indexed Atlassian titles far more often than abstract job titles.

Widen `customDomains` beyond the defaults. Public service desks frequently publish a corporate address, so adding domains such as `@outlook.com` or a specific company domain often unlocks rows the default `@gmail.com` and `@yahoo.com` pair never sees.

Leave `expandQueries` on. With Jira's small indexed footprint, the extra phrasings are usually the difference between a handful of rows and a usable list.

Raise `maxPagesPerQuery` only when a run is clearly still producing new emails on later pages. The Jira Email Scraper already stops a query after several consecutive pages with nothing new, so a high cap costs little but rarely helps once the index is exhausted.

Run the Jira Email Scraper more than once with different keyword sets rather than one enormous run. Deduplication is per run, so merge datasets afterwards in your own tooling.

Keep `maxConcurrency` moderate. Five parallel queries is the default because it balances throughput against Google's block rate, and the Jira Email Scraper already retries and requeues anything that gets blocked.

### Limitations you should know before running the Jira Email Scraper

**Most Jira sites are private.** Only public issue trackers and service desks are indexed, so expect modest volume. This is the single biggest constraint on any run.

The Jira Email Scraper only finds addresses that are **publicly visible in Google's index**. Anything behind a login, inside an attachment or rendered by JavaScript is invisible to it.

Google caps a single query at roughly 300 results. Query expansion is the workaround, not a way around the cap itself.

`username` and `profileUrl` are only populated when Google's result exposes the Atlassian subdomain. Rows sourced from `atlassian.com` pages rather than a customer subdomain can arrive with `accountName` filled in and `username` set to `null`. That is a Google limitation, not a bug.

`possiblyTruncated: true` means Google's snippet ellipsis touched the address and it may be cut off. Verify those before sending anything.

The Actor requires the Apify **GOOGLE_SERP proxy** and cannot run without Apify proxy credentials. Free Apify plans are capped at 100 emails per run; paid plans are uncapped.

Results vary with keywords, domains, country and timing. No volume is guaranteed, and `accountName` on Jira usually identifies an organisation rather than a named person.

### Responsible use

Contact addresses published on a public service desk or issue tracker are there so that outsiders can correspond with the project or the team. Use them for that purpose.

Respect GDPR and equivalent local rules, honour opt-outs immediately, and follow each project's stated contact norms. Do not send unrelated bulk marketing to an address published for support or security reports.

The Jira Email Scraper is a discovery tool, not a sending tool. What you do with the dataset is entirely your responsibility.

### Jira Email Scraper FAQ

#### Does the Jira Email Scraper use the Jira or Atlassian API?

No. It does not use any Atlassian API, does not read Jira issue data directly and never opens a Jira site. Every field comes from Google search result blocks fetched through the Apify GOOGLE_SERP proxy.

#### Does it log into Jira or access private issues?

No. There is no authentication, no cookies and no browser. If a page is not publicly indexed by Google, the Jira Email Scraper cannot see it.

#### Why did I get fewer results than I expected?

Because most Jira sites are private. Only public issue trackers and service desks are indexed, so expect modest volume even with good keywords.

#### What does `accountName` contain on Jira?

Usually an organisation — the company or community that owns the Atlassian site — rather than an individual person. Plan your outreach copy accordingly.

#### How is `profileUrl` built?

From the Atlassian subdomain, in the shape `https://{username}.atlassian.net/`. Jira Cloud gives every customer its own subdomain, which is why the Jira Email Scraper can recover a handle far more often than on platforms that only show display names.

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

Because Google's result did not expose a customer subdomain — for example when the hit is on a generic `atlassian.com` page. Those rows still carry `accountName`, `email` and `description`.

#### Which email domains does the Jira Email Scraper collect?

Only the domains in `customDomains`, defaulting to `@gmail.com` and `@yahoo.com`. Matching is boundary-correct, so `@gmail.com` never matches inside `@gmail.company` or `@gmail.com.br`.

#### Does the Jira Email Scraper handle obfuscated addresses?

Yes. It normalises `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the full-width `＠` sign before filtering by domain.

#### Can I restrict the Jira Email Scraper to one country?

Set `countryCode` to a two-letter code such as `DE` or `GB`. That steers the search proxy; combine it with a `location` phrase for tighter geographic targeting.

#### What is `possiblyTruncated` for?

It flags rows where Google's snippet ellipsis touched the email address, so the local part or domain may be incomplete. Verify before sending.

#### Do I need a proxy?

Yes. The Jira Email Scraper runs on the Apify GOOGLE_SERP proxy and cannot operate without Apify proxy credentials.

#### What happens if Google changes its HTML?

Parsing is structural rather than class-name based, and a whole-page fallback parser exists. A layout change degrades the Jira Email Scraper to "emails without account details" rather than "no emails at all".

### Related Actors

The Jira Email Scraper belongs to a family of 32 Developer & Technology email Actors that share the same engine and differ only in the platform they target.

| Actor | What it collects |
|---|---|
| [Jira Email and Phone Number Scraper](https://apify.com/neuro-scraper/jira-email-and-phone-number-scraper) | Emails and phone numbers from Jira |
| [Jira Phone Number Scraper](https://apify.com/neuro-scraper/jira-phone-number-scraper) | Public phone numbers from Jira |
| [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 |
| [Dev.to Email Scraper](https://apify.com/neuro-scraper/dev-to-email-scraper) | Public contact emails from DEV Community |
| [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 |
| [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 |
| [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 |
| [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 |

### Leave a review

If the Jira 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 report or a custom build request for the Jira Email Scraper? Email **neurodata.apify@gmail.com**.

# Actor input Schema

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

Search terms describing the Jira 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 Jira.

## `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": [
    "project manager",
    "service desk"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "countryCode": "",
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "support",
    "admin",
    "service desk"
  ],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Records produced by Jira 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": [
        "project manager",
        "service desk"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "support",
        "admin",
        "service desk"
    ]
};

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

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

```

## MCP server setup

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