# GitLab Email Scraper (`neuro-scraper/gitlab-email-scraper`) Actor

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

- **URL**: https://apify.com/neuro-scraper/gitlab-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

### GitLab Email Scraper - find public developer and maintainer emails on GitLab

The **GitLab Email Scraper** is an Apify Actor that collects publicly indexed contact emails tied to GitLab users, groups, projects and GitLab Pages sites. Give it keywords, an optional location and your email domains, and it returns a structured lead dataset.

GitLab is where a lot of engineering work lives in the open: project `README` files, `CONTRIBUTING` and `SECURITY` docs, CI configuration notes, merge request discussions, group landing pages and documentation published to `gitlab.io`.

Wherever a maintainer has written a contact address on one of those public pages and Google has indexed it, the GitLab Email Scraper can pick it up and hand it to you as a row with a handle and a profile URL.

#### What the GitLab Email Scraper reads - and what it never touches

The GitLab Email Scraper reads **only Google's public index** of `gitlab.com` and `gitlab.io`. It builds `site:` queries, fetches Google result pages through the Apify GOOGLE_SERP proxy, and extracts emails from the result titles and snippets.

It does **not** read git history, clone repositories, or call the GitLab API - which is important, because the GitLab Users API only exposes other people's email addresses to instance administrators.

There is no login, no access token, no browser, no JavaScript rendering and no cookies. Self-managed GitLab instances on private domains are out of scope; only `gitlab.com` and `gitlab.io` are queried.

#### Who uses the GitLab Email Scraper

Technical recruiters who want engineers with demonstrable DevOps and CI experience, developer relations teams mapping an ecosystem, agencies doing developer lead generation, and maintainers looking for peer projects to partner with.

If you have ever searched for a way to find a GitLab user's email address and hit the admin-only API wall, this Actor is the practical alternative that works from public data.

***

### Key features of the GitLab Email Scraper

| Feature | What it does |
|---|---|
| Google `site:` dorking | Queries `gitlab.com` and `gitlab.io` through the Apify GOOGLE_SERP proxy |
| Query expansion | 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 address across the whole 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 | Discards a hit that is only the tail of another email in the same block |
| Structural parsing | Finds the `<h3>` title then the smallest surrounding block, not Google's CSS class names |
| Whole-page fallback | A Google layout change degrades the run to "emails without account details", not "no emails" |
| Block detection | CAPTCHA, "unusual traffic" and consent pages are detected and retried rather than counted as empty |
| Retries and backoff | Up to 3 attempts per page, exponential backoff, 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 | Key-value-store progress keyed by an input hash, with throttled saves plus saves on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Streaming output | Leads are pushed to the dataset as they are found, so an aborted run keeps what it collected |
| Run summary | Logs pages fetched, blocked pages, retries and emails per page |

***

### How the GitLab Email Scraper works

The GitLab Email Scraper pipeline is six steps long, with no browser and no authentication anywhere in it.

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

#### Why query expansion matters here

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

The GitLab Email Scraper works around that by combining every keyword with every email domain in several phrasings, giving each variant its own result budget.

The default `queryModifiers` - `email`, `contact`, `maintainer`, `author`, `support` - are the words that genuinely appear next to addresses in GitLab project documentation and group descriptions.

#### What the GitLab Email Scraper does not do

No login, no personal access token, no GitLab API, no repository cloning, no commit-history parsing, no JavaScript rendering. It is an independent Apify Actor and is not affiliated with or endorsed by GitLab.

***

### GitLab Email Scraper input fields

`keywords` is the only required field in the GitLab Email Scraper. Every default below is the one shipped in the Actor's input schema.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["developer", "maintainer"]` | Search terms describing the GitLab accounts you want (niche, job title, industry) |
| `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 GitLab Email Scraper input

```json
{
  "keywords": ["ci cd engineer", "kubernetes maintainer", "platform engineer"],
  "location": "Amsterdam",
  "customDomains": ["@gmail.com", "@protonmail.com"],
  "maxEmails": 400,
  "countryCode": "NL",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "maintainer", "author", "support"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

#### Tuning the GitLab Email Scraper

Narrow keywords out-perform broad ones in the GitLab Email Scraper. `gitlab runner maintainer` beats `developer`, because it matches the vocabulary people actually use on project pages.

When a run comes back thin, add domains before you add keywords. Each additional domain multiplies the number of distinct queries and therefore the total result budget.

Keep `expandQueries` on unless you are running a quick smoke test - turning it off collapses the GitLab Email Scraper to a single query per keyword and domain pair.

***

### GitLab Email Scraper output fields

Every dataset item the GitLab Email Scraper produces has all 14 fields. Nothing is omitted; values are empty or `null` when Google did not expose them.

| 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 group name) |
| `fullName` | Display name parsed from a profile-style title; empty for project or doc pages |
| `username` | URL-safe GitLab handle or namespace when one is exposed; otherwise `null` |
| `profileUrl` | Canonical `https://gitlab.com/{username}` URL when a handle is known; otherwise empty |
| `url` | Direct platform link when exposed, else the profile URL |
| `description` | Bio or snippet text, 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 GitLab Email Scraper output

```json
[
  {
    "network": "GitLab",
    "keyword": "ci cd engineer",
    "query": "site:gitlab.com ci cd engineer \"@gmail.com\" \"Amsterdam\"",
    "title": "Daan Verhoeven (dverhoeven) - GitLab",
    "accountName": "dverhoeven",
    "fullName": "Daan Verhoeven",
    "username": "dverhoeven",
    "profileUrl": "https://gitlab.com/dverhoeven",
    "url": "https://gitlab.com/dverhoeven",
    "description": "Platform engineer in Amsterdam. CI pipelines, runners, Terraform. Contact daan.verhoeven.dev@gmail.com",
    "email": "daan.verhoeven.dev@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T10:02:41.117Z"
  },
  {
    "network": "GitLab",
    "keyword": "kubernetes maintainer",
    "query": "site:gitlab.com intitle:\"kubernetes maintainer\" \"@gmail.com\"",
    "title": "helios-infra / helios-operator - CONTRIBUTING",
    "accountName": "helios-infra",
    "fullName": "",
    "username": "helios-infra",
    "profileUrl": "https://gitlab.com/helios-infra",
    "url": "https://gitlab.com/helios-infra/helios-operator",
    "description": "Maintainers reachable at helios.maintainers@gmail.com for security reports and release ...",
    "email": "helios.maintainers@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": true,
    "foundAt": "2026-08-31T10:02:55.640Z"
  },
  {
    "network": "GitLab",
    "keyword": "platform engineer",
    "query": "site:gitlab.io platform engineer contact \"@protonmail.com\"",
    "title": "Handbook - Contact",
    "accountName": "Handbook",
    "fullName": "",
    "username": null,
    "profileUrl": "",
    "url": "https://northwind-platform.gitlab.io/handbook/contact/",
    "description": "Questions about the platform team? Write to northwind.platform@protonmail.com",
    "email": "northwind.platform@protonmail.com",
    "emailDomain": "@protonmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T10:03:12.008Z"
  }
]
```

The third row shows the honest edge case: a GitLab Pages site on `gitlab.io` publishes a real address but no GitLab handle, so `username` is `null` and `profileUrl` is empty. The GitLab Email Scraper reports that rather than guessing a URL.

***

### Use cases for the GitLab Email Scraper

| Use case | How the GitLab Email Scraper helps |
|---|---|
| Technical recruiting | Source engineers by stack, role and city, with a profile URL you can review first |
| DevOps and platform sourcing | GitLab skews toward CI/CD and infrastructure work, so keyword targeting is unusually precise |
| Developer relations | Find maintainers of adjacent projects before a launch, beta or integration push |
| Open-source outreach | Reach the contact addresses published in `README`, `CONTRIBUTING` and `SECURITY` docs |
| Developer lead generation | Fill a devtools or API pipeline with accounts matching a technical niche |
| Partnership research | Identify groups and organisations shipping tooling in your category |
| Security disclosure | Collect published security contacts for projects in your dependency tree |
| Ecosystem research | Measure how many projects in a niche publish a public contact channel at all |

#### Sourcing infrastructure engineers

GitLab's centre of gravity is CI/CD, runners and self-hosted delivery, so the GitLab Email Scraper is a sharper instrument than a general web scrape when you are hiring for platform roles.

Pair it with the [GitHub Email Scraper](https://apify.com/leads-scraper/github-email-scraper) to cover engineers who keep their public code on one host and their day job on the other.

#### Building a launch list

DevRel teams commonly run the GitLab Email Scraper alongside the [Docker Hub Email Scraper](https://apify.com/neuro-scraper/docker-hub-email-scraper), since the people publishing pipelines and the people publishing images are largely the same population.

***

### Expected results from the GitLab Email Scraper

In live test runs against Google, about **8 out of 10 parsed GitLab results carried an account identity** - a handle, a display name, or both - and profile URLs resolved reliably.

That is the strongest coverage in this Developer & Technology family, because GitLab's user and namespace titles are consistently formatted in Google's index.

GitLab Email Scraper rows without a handle still carry `email`, `emailDomain`, `url`, `description` and `query`. Total volume always depends on your keywords, domains and location; no yield is guaranteed.

***

### Limitations of the GitLab Email Scraper

- **Publicly indexed emails only.** An address is findable only when it is already visible in Google's index. Private projects, unindexed pages and addresses users never published are unreachable.
- **No git history, no GitLab API.** Commit author emails and API responses are not read. Only Google result titles and snippets are parsed.
- **Only `gitlab.com` and `gitlab.io`.** Self-managed GitLab instances on private domains are not queried.
- **Google's ~300-result cap.** One query returns roughly 300 results at most, which is exactly why `expandQueries` exists.
- **`possiblyTruncated`.** When `true`, Google's snippet ellipsis touched the email and it may be cut off. Verify those rows before sending.
- **`username` and `profileUrl` can be empty.** They are filled only when GitLab exposes a handle in the result. Some `gitlab.io` pages and documentation files show only a display name, leaving `accountName` populated but `username` `null`.
- **Apify GOOGLE_SERP proxy required.** The GitLab Email Scraper 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.** Google's index moves, so two runs a month apart will not be identical.

***

### Responsible use

Emails the GitLab Email Scraper returns were published on GitLab project pages for project correspondence: bug reports, security disclosures, release questions, contribution coordination.

If you contact people in the EU or UK, GDPR applies. Have a lawful basis, identify yourself clearly, say where you found the address, and honour opt-out requests straight away.

Respect the norms of the platform and of individual projects. A `README` that says "no recruiters" means no recruiters, and relevance beats volume every single time.

***

### GitLab Email Scraper FAQ

#### Does the GitLab Email Scraper use the GitLab API?

No. It does not call the GitLab API, read git history or clone repositories. It parses Google search results for already-indexed public pages on `gitlab.com` and `gitlab.io`.

#### Do I need a GitLab account or personal access token?

No. There is no authentication of any kind. The only credential involved is your Apify account's GOOGLE_SERP proxy access.

#### Can it search a self-managed GitLab instance?

No. The GitLab Email Scraper queries `gitlab.com` and `gitlab.io` only. A private instance on your own domain is not covered.

#### Where do the emails come from?

The GitLab Email Scraper takes them from the text Google prints in titles and snippets: profile bios, group and project descriptions, `README` and `CONTRIBUTING` files, merge request and issue text, and GitLab Pages documentation.

#### How many emails can one GitLab Email Scraper run return?

`maxEmails` accepts 1 to 10000 and defaults to 20. Free Apify plans are capped at 100 emails per run; paid plans are uncapped.

#### Why is `username` `null` on some rows?

Because Google did not expose a GitLab handle for that result. The row is still a usable lead with `email`, `accountName`, `url` and `description`.

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

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

#### Can the GitLab Email Scraper collect only company-domain emails?

Yes. Set `customDomains` to the domains you want, for example `["@acme.io", "@example.com"]`. The leading `@` is optional and only matching addresses are kept.

#### Does it handle `name [at] gmail [dot] com` style obfuscation?

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

#### How do I target one country?

Set `countryCode` to a two-letter code such as `US`, `GB` or `DE`, and put a city or region into `location` so it is appended to every query.

#### What happens if a GitLab Email Scraper run is interrupted or migrated?

State is saved in the key-value store keyed by a hash of your input, including on `PERSIST_STATE`, `MIGRATING` and `ABORTING`. Leads already pushed to the dataset are never lost.

#### Will a Google redesign break it?

Parsing is structural rather than class-name based and there is a whole-page fallback parser, so a layout change degrades the GitLab Email Scraper to "emails without account details" instead of nothing.

***

### Related Actors

The GitLab Email Scraper belongs to a Developer & Technology family of Apify Actors that apply the same method to different platforms. Running several gives you ecosystem coverage instead of a single-site snapshot.

| Actor | What it collects |
|---|---|
| [GitLab Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-email-and-phone-number-scraper) | Emails and phone numbers from GitLab |
| [GitLab Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-phone-number-scraper) | Public phone numbers from GitLab |
| [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 |
| [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 |
| [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 |
| [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 GitLab 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

Need help, found a bug, or want a custom build of the GitLab Email Scraper tuned to your own domain list? Email **neurodata.apify@gmail.com**.

# Actor input Schema

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

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

## `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",
    "maintainer"
  ],
  "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 GitLab 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",
        "maintainer"
    ],
    "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/gitlab-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",
        "maintainer",
    ],
    "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/gitlab-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",
    "maintainer"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "maintainer",
    "author",
    "support"
  ]
}' |
apify call neuro-scraper/gitlab-email-scraper --silent --output-dataset

```

## MCP server setup

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