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

GitLab Profile Email Scraper SD - GitLab Profile Email Scraper is a lead generation tool that extracts leads with public contact emails, bio, follower counts and profile URLs from GitLab profile URLs or usernames - GitLab profile scraper for creator outreach.

- **URL**: https://apify.com/neuro-scraper/gitlab-profile-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.99 / 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 Profile Email Scraper

**GitLab Profile Email Scraper** produces a clean dataset of public contact emails and profile data
from two kinds of input. Give it **keywords** and it harvests GitLab accounts that publish a contact
address; give it **profile URLs or usernames** and it opens the accounts you already have.

A keyword run is not a word match. The GitLab Profile Email Scraper asks Google for indexed GitLab
pages carrying both your term and a published address, then fetches every account it finds for
profile data and merges the two into one row.

Keywords, URLs and handles combine in a single run, and a run needs only one of them. The GitLab
Profile Email Scraper is built for developer outreach, technical recruiting and lead enrichment.

Be clear about the scope. The **GitLab Profile Email Scraper** reads the **public profile page**,
plus public search results for pages GitLab published. It never reads commit metadata,
`.patch` files or the events API.

**GitLab profiles expose a name, a bio and an avatar rather than follower statistics.** Expect the
follower and following counts to come back empty on most rows.

***

### What the GitLab Profile Email Scraper does

The **GitLab Profile Email Scraper** runs in two phases, and the order is the whole design: it
harvests accounts and addresses together first, then fills in the profile data.

#### Phase 1 — Google harvest, on the GOOGLE\_SERP proxy

When keywords are given, the GitLab Profile Email Scraper searches Google with an email dork —
`site:gitlab.com platform engineer "@gmail.com"` — instead of searching for the term on its own.

Each query is expanded across your keywords, the query modifiers and the address domains, and paged
up to `maxPagesPerKeyword`. Each result block yields the account handle and the address published on
that page in one request.

Google no longer prints the target URL on most layouts, so the handle comes from what it does print:
the "GitLab - handle" site label, the breadcrumb host and path, or a `Name (@handle)` title.

This is where the volume and most of the addresses come from. Asking for pages that already carry an
address costs roughly one request per ten accounts.

#### Phase 2 — profile enrichment, on the RESIDENTIAL proxy

The GitLab Profile Email Scraper then fetches every account found for its real profile data — name,
bio, avatar, external URL — and merges it into one row with the address from phase 1. Supplied URLs
and usernames skip phase 1 and start here.

End to end:

1. Reads your input: `keywords` and/or `profileUrls` / `usernames`, plus limits and filters.
2. Harvests handles and their published addresses from Google, on the GOOGLE\_SERP proxy.
3. Normalises every target to a canonical profile URL, dropping duplicates.
4. Fetches each profile on the **RESIDENTIAL proxy**, several in parallel, with a fresh exit IP on
   every retry.
5. Parses it with a regex-first cascade: a regex battery against the raw HTML, then a generic
   parser, then Open Graph / link-preview meta tags.
6. Merges the harvested address with any in the bio, display name and external URL, and applies the
   email hygiene described below.
7. Pushes one row per account to the dataset immediately, then saves progress.

Enrichment starts the moment the harvest finds an account, so the first rows save seconds into a run
and keep arriving while the search continues. Each row is logged as written, naming the handle, the
address and the counts found.

The first profile request sends a full Chrome header set — client hints, referer, the sec-fetch
family — and a retry falls back to a plain set, because some sites answer one and not the other.

Matching key names in the HTML rather than following an object path is deliberate: platforms move
those objects between releases, and the key names tend to survive, so the GitLab Profile Email
Scraper keeps working across front-end changes.

**No login, no cookies, no private or official API, and no browser or JavaScript rendering.** The
**GitLab Profile Email Scraper** reads only what an anonymous visitor can already see.

***

### Finding accounts by keyword

Keywords are a real harvest of GitLab accounts, not a filter over URLs you supplied. `expandQueries`
is on by default, so each keyword is also searched with the query modifiers — `email`, `contact`,
`maintainer`, `author`, `support` here — and with each address domain in turn.

The harvest runs on the **GOOGLE\_SERP proxy**, up to `maxPagesPerKeyword` pages per query, with
`location` appended when you set it. The profile fetch stays on the **RESIDENTIAL proxy**; neither
proxy group can do the other's job.

The GitLab Profile Email Scraper enriches every account discovered exactly like one you supplied:
same canonical URL, same parser, same row shape. Keyword search only decides **which accounts get
read** — it never widens the scope past the public profile page and public search results.

***

### What this GitLab email finder returns, and what it does not

The honest part, worth reading before your first **GitLab Profile Email Scraper** run: GitLab
publishes less than most platforms.

**GitLab profiles expose a name, bio and avatar rather than follower statistics.** GitLab publishes
no counts at all to a signed-out visitor, so a GitLab row carries no `followersCount`,
`followingCount`, `postsCount` or `likesCount` column.

The GitLab Profile Email Scraper reliably returns the contact layer: `fullName`, `bio`, `avatarUrl`,
and `email` / `emails` when the developer published an address. A field an individual account leaves
empty comes back `null` or `""` — normal output, not an error.

#### Scope limit: public profile pages and public search results

Many email finder tools for git hosts scrape commit metadata or append `.patch` to a commit URL,
surfacing the address a developer's `git` client attached to a commit and never intended to publish.
The GitLab Profile Email Scraper does not.

It reads two things, both public. The **profile page**, for the name, bio, avatar and external URL.
And **public search results for pages GitLab published**, where a harvested address comes
from the result shown.

That distinction is the whole point: the GitLab Profile Email Scraper never digs an address out of
commit history, `.patch` files or the events API. It finds addresses a developer chose to publish on
an already-indexed page, and returns `email: null` when there are none.

***

### Input schema

Every input field the **GitLab Profile Email Scraper** accepts, as shipped:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array | prefilled with example terms | Search terms. The GitLab Profile Email Scraper harvests GitLab accounts publishing an address alongside each term, then enriches every 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`, ...) to reach accounts a single query misses. Keyword search only. |
| `queryModifiers` | array | `email`, `contact`, `maintainer`, `author`, `support` | Extra words combined with each keyword when expansion is on. |
| `profileUrls` | array | `[]` | Full GitLab profile URLs. Bare usernames also accepted. |
| `usernames` | array | `[]` | Handles without the URL. Combined with the list above. |
| `customDomains` | array | `[]` | Domains the keyword search asks Google for, and a filter on the addresses kept. Empty searches the common free-mail providers and keeps every address found. |
| `onlyWithEmail` | boolean | `false` | Skip accounts for which no public address was found. |
| `maxProfiles` | integer 1-100000 | `100` | Stop after this many profiles are saved. |
| `maxConcurrency` | integer 1-30 | `10` | How many profiles are fetched, and Google searches run, in parallel. 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. |

There is no `dataSource` input and no per-account Google email search here; both belong to the
TikTok sibling. Every GitLab Profile Email Scraper row reports `dataSource` as `page`.

#### JSON input example

Both ways in, in one run. Drop `keywords` to enrich a list you have, or drop the URL lists to let
the **GitLab Profile Email Scraper** find the accounts for you.

```json
{
  "keywords": [
    "platform engineer",
    "sre kubernetes"
  ],
  "location": "",
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "maintainer"
  ],
  "profileUrls": [
    "https://gitlab.com/example-maintainer",
    "third-contributor"
  ],
  "usernames": [
    "fourth_dev",
    "@fifth-dev"
  ],
  "customDomains": [],
  "onlyWithEmail": true,
  "maxProfiles": 500,
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": "US"
}
```

***

### Output schema

Every dataset row produced by the **GitLab Profile Email Scraper** has these fields:

| Field | Meaning |
|---|---|
| `success` | True when the profile was fetched and parsed, **or** an address was found for the account. A blocked profile fetch still yields a usable row when the harvest supplied an address. |
| `network` | Platform name |
| `dataSource` | Which path produced the profile data — always `page` on this Actor |
| `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, the common value on a keyword run), `bio` (the profile page), `bio+search`, or `null` |
| `bio` | Public bio / description text |
| `avatarUrl` | Profile picture URL |
| `error` | Why a row failed, or `null` |
| `scrapedAt` | ISO 8601 UTC timestamp |

#### JSON output example

A realistic row from the GitLab Profile Email Scraper, with the fields GitLab does not publish left
as `null` or `""`:

```json
{
  "success": true,
  "network": "GitLab",
  "dataSource": "page",
  "keyword": "platform engineer",
  "query": "site:gitlab.com platform engineer contact \"@gmail.com\"",
  "description": "Alex Rivera - platform engineer, CI/CD and Kubernetes. Contact: hi at alexrivera.dev",
  "profileUrl": "https://gitlab.com/example-maintainer",
  "url": "https://gitlab.com/example-maintainer",
  "username": "example-maintainer",
  "fullName": "Alex Rivera",
  "displayName": "Alex Rivera",
  "email": "hi@alexrivera.dev",
  "emails": ["hi@alexrivera.dev"],
  "emailSource": "bio+search",
  "bio": "Platform engineer. CI/CD and Kubernetes. hi [at] alexrivera [dot] dev",
  "avatarUrl": "https://gitlab.com/uploads/-/system/user/avatar/000000/avatar.png",
  "error": null,
  "scrapedAt": "2025-01-14T09:22:41Z"
}
```

***

### How email extraction works

The **GitLab Profile Email Scraper** applies the same hygiene to harvested and bio addresses alike,
because raw regex produces a lot of junk. Four rules do most of the work.

- **Obfuscation is undone before matching**: `[at]`, `(dot)`, spaced `a @ b`, zero-width characters
  and full-width `＠` are all normalised first.
- **Boundary-correct domain matching**, so `@gmail.com` does not match inside `@gmail.company`.
- **Placeholder locals are dropped**: `email@`, `yourname@`, `example@`, `noreply@` and similar
  never reach your dataset.
- **Prose words are dropped as locals** (`the@`, `more@`), while real role addresses such as `hi@`,
  `hey@` and `hello@` are deliberately kept.

Developers obfuscate their addresses more than most audiences do, so `name [at] domain [dot] dev` is
a normal find for a GitLab bio email extractor.

***

### How to use the GitLab Profile Email Scraper

Step by step:

1. Open the **GitLab Profile Email Scraper** on Apify and click **Try for free**.
2. Type search terms such as `platform engineer` into **Keywords**. The GitLab Profile Email Scraper harvests GitLab
   accounts publishing an address alongside that term.
3. Optionally set **Location**, and raise **Pages per keyword** from `5` to reach further down.
4. Leave **Expand queries** on so each keyword is also searched with **Query modifiers**; edit that
   list to steer the harvest towards your niche.
5. Or paste accounts you already have into **GitLab profile URLs** and **Usernames / handles**. Full
   URLs, bare handles and `@handles` all normalise to one canonical form and deduplicate.
6. Set **Max profiles** to cap the run. The default is `100`, which is also the free-plan cap.
7. Turn on **Only save profiles that have an email** for a contact list rather than a profile audit.
8. Optionally list domains under **Email domains** — the domains the harvest asks Google for and the
   filter on what is kept, so corporate-only runs start here.
9. Leave **Apify proxy group** on `RESIDENTIAL`. Profile pages block datacenter IPs.
10. Lower **Max concurrency** from `10` if you see blocked rows in the log; raise it, up to `30`,
    when runs are clean.
11. Click **Start**, then export as JSON, CSV, Excel or XML, or pull the rows through the Apify API.

#### Building the input list

The GitLab Profile Email Scraper can build the list for you from keywords, or enrich one you already
have — members of a public GitLab group, contributors to a project you depend on, or a CRM export of
known handles.

***

### Who uses the GitLab Profile Email Scraper

A keyword run returns developers who published a way to reach them, not every account that happens
to contain the word.

**Technical recruiting and talent sourcing.** Point the GitLab Profile Email Scraper at contributors
to projects in your stack and get a sourcing pipeline with a name, bio and a published address.

**Developer relations and community outreach.** Reach maintainers of projects that integrate with
your product. The bio field the GitLab Profile Email Scraper returns is a strong signal of what
someone works on.

**Developer marketing and lead generation.** A GitLab lead generation workflow beats a purchased
list: every row traces back to a live profile URL, and `keyword` and `query` record which search
produced it.

**DevOps and platform tooling sales.** GitLab skews toward CI/CD and platform teams, so the bios the
GitLab Profile Email Scraper collects align well with infrastructure prospecting.

**Open source program offices.** Track the maintainer set of your dependency tree, or build a
contributor directory with names and avatars.

***

### Behaviour, limits and pricing

- **Free Apify plan**: capped at **100 profiles** per run. Paid plans are uncapped.
- **Pay-per-event**: the GitLab Profile Email Scraper charges `actor-start` once, plus
  `profile-scraped` per saved row.
- **Resumable**: progress is keyed to a hash of the input, so a migrated or restarted run continues
  instead of refetching. Changing the input starts a clean run.
- **Retries**: up to 4 attempts per page with exponential backoff and a fresh exit IP each time. A
  login redirect counts as rate limiting, not a missing profile.
- **Run summary**: each run reports counts of ok / blocked / not found / errors at the end.

***

### Limitations of the GitLab Profile Email Scraper

Every point below is a real limit of the GitLab Profile Email Scraper, not a disclaimer.

**Follower statistics are absent.** GitLab publishes none of them to an anonymous visitor, so a
GitLab row carries no `followersCount`, `followingCount`, `postsCount` or `likesCount` column.

**Public profile pages and public search results only.** No commit metadata, no `.patch` files, no
events API — none of the routes used to extract addresses a developer did not publish. The harvest
reads Google results for pages GitLab published, which is not digging through commit history.

**Only emails the person published, and yield varies.** The harvest asks for pages that publish an
address, so most keyword rows carry one — but how many depends on the niche, and there is no rate to
promise. If nothing was published anywhere indexed, the row comes back with `email: null`.

**Keyword search needs the GOOGLE\_SERP proxy.** It is the only route to Google, so a keywords-only
run fails with a clear message without it. A run that also supplies profile URLs warns and continues.

**Public data only.** No login, no cookies, no private or official API, no browser or JavaScript
rendering. GitLab publishes no verified or private flag on a profile page, so a GitLab row carries
neither column - what it returns is the name, bio, avatar and any published address.

**Rate limiting happens.** Residential proxies and retries reduce it but do not eliminate it. A
blocked fetch on an account with no harvested address returns `success: false` and a reason in
`error`.

**gitlab.com only.** Self-hosted GitLab instances on your own domain are not covered.

**Your compliance is yours.** The GitLab Profile Email Scraper collects public data; how you store
and use contact addresses under GDPR, CAN-SPAM or local law is your responsibility.

***

### GitLab Profile Email Scraper FAQ

#### How does keyword search work?

In two phases. First a Google harvest on the GOOGLE\_SERP proxy, using an email dork —
`site:gitlab.com <keyword> "@gmail.com"` — expanded across keywords, query modifiers and
address domains and paged up to `maxPagesPerKeyword`, so each result yields a handle and a
published address together.

Then profile enrichment on the RESIDENTIAL proxy, merging both into one row.

#### Why harvest first instead of just fetching profiles?

Because pages that already carry an address return handles and emails in the same request, while
fetching every profile and hoping for a bio address is one request each, and most bios have none.

#### Do profile URLs and usernames still work?

Yes, unchanged. Accounts you list directly skip the harvest and are enriched first, then whatever
the harvest discovers.

#### Does it find emails hidden in commits or `.patch` files?

No. The GitLab Profile Email Scraper reads the public profile page and public search results for
pages GitLab published, never commit metadata, `.patch` URLs or the events API.

#### Why is `followersCount` null on almost every row?

Because GitLab profiles expose a name, bio and avatar rather than follower statistics. This is a
property of the page a signed-out visitor sees, not a parsing failure.

#### Which fields can I rely on?

`username`, `profileUrl`, `fullName`, `bio`, `avatarUrl`, and `email` / `emails` /
where the developer published them.

#### Do I need a GitLab account, token or API key?

No. No login, no cookies, no official API and no token. Only publicly visible data is collected, and
anything requiring a session is out of scope.

#### Can I filter to corporate domains only?

Yes. `customDomains` does two jobs: it sets the address domains the harvest asks Google for, and it
filters what is kept. Leave it empty to search the common free-mail providers and keep everything.
Set `onlyWithEmail` to skip accounts where no address was found.

#### What does `emailSource` mean here?

Where an address came from: `search` (the Google harvest, the common value on a keyword run), `bio`
(the profile page), `bio+search`, or `null` when none was found.

#### What are `keyword`, `query` and `description` for?

The term that found the account, the exact Google query that found it, and the result snippet Google
showed, cleaned of labels and counters. All three are empty for an account you supplied directly.

#### Why is `success` true on a row with no profile data?

Because `success` is true when the profile was fetched **or** an address was found. A blocked fetch
on an account the harvest already had an address for still gives you a usable contact row.

#### What happens if a run is interrupted, and how large can a run be?

The GitLab Profile Email Scraper keys progress to a hash of the input, so a restarted or migrated run
resumes where it stopped. `maxProfiles` accepts up to 100000 on paid plans; free plans are capped at
100 per run.

***

### Related Actors

The GitLab Profile Email Scraper is one of a family of 30 profile email scrapers that share the same
input schema, output schema and email hygiene.

| Actor | What it collects |
|---|---|
| [GitLab Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitLab |
| [GitLab Profile Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-profile-phone-number-scraper) | Phone numbers plus bio and follower counts from GitLab profiles |
| [Behance Profile Email Scraper](https://apify.com/leads-scraper/behance-profile-email-scraper) | Emails plus bio and follower counts from Behance profiles |
| [Bluesky Profile Email Scraper](https://apify.com/leads-scraper/bluesky-profile-email-scraper) | Emails plus bio and follower counts from Bluesky profiles |
| [Buy Me a Coffee Profile Email Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-scraper) | Emails plus bio and follower counts from Buy Me a Coffee profiles |
| [DEV Community Profile Email Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-scraper) | Emails plus bio and follower counts from DEV Community profiles |
| [DeviantArt Profile Email Scraper](https://apify.com/leads-scraper/deviantart-profile-email-scraper) | Emails plus bio and follower counts from DeviantArt profiles |
| [Dribbble Profile Email Scraper](https://apify.com/leads-scraper/dribbble-profile-email-scraper) | Emails plus bio and follower counts from Dribbble profiles |
| [Facebook Profile Email Scraper](https://apify.com/leads-scraper/facebook-profile-email-scraper) | Emails plus bio and follower counts from Facebook profiles |
| [Flipboard Profile Email Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-scraper) | Emails plus bio and follower counts from Flipboard profiles |
| [GitHub Profile Email Scraper](https://apify.com/leads-scraper/github-profile-email-scraper) | Emails plus bio and follower counts from GitHub profiles |
| [Gumroad Profile Email Scraper](https://apify.com/leads-scraper/gumroad-profile-email-scraper) | Emails plus bio and follower counts from Gumroad profiles |
| [Hashnode Profile Email Scraper](https://apify.com/neuro-scraper/hashnode-profile-email-scraper) | Emails plus bio and follower counts from Hashnode profiles |
| [Hugging Face Profile Email Scraper](https://apify.com/neuro-scraper/hugging-face-profile-email-scraper) | Emails plus bio and follower counts from Hugging Face profiles |
| [Instagram Profile Email Scraper](https://apify.com/leads-scraper/instagram-profile-email-scraper) | Emails plus bio and follower counts from Instagram profiles |
| [Kick Profile Email Scraper](https://apify.com/leads-scraper/kick-profile-email-scraper) | Emails plus bio and follower counts from Kick profiles |
| [Linktree Profile Email Scraper](https://apify.com/leads-scraper/linktree-profile-email-scraper) | Emails plus bio and follower counts from Linktree profiles |
| [Mastodon Profile Email Scraper](https://apify.com/leads-scraper/mastodon-profile-email-scraper) | Emails plus bio and follower counts from Mastodon profiles |
| [Mixcloud Profile Email Scraper](https://apify.com/leads-scraper/mixcloud-profile-email-scraper) | Emails plus bio and follower counts from Mixcloud profiles |
| [Patreon Profile Email Scraper](https://apify.com/leads-scraper/patreon-profile-email-scraper) | Emails plus bio and follower counts from Patreon profiles |
| [Pinterest Profile Email Scraper](https://apify.com/leads-scraper/pinterest-profile-email-scraper) | Emails plus bio and follower counts from Pinterest profiles |
| [Snapchat Profile Email Scraper](https://apify.com/leads-scraper/snapchat-profile-email-scraper) | Emails plus bio and follower counts from Snapchat profiles |
| [SoundCloud Profile Email Scraper](https://apify.com/leads-scraper/soundcloud-profile-email-scraper) | Emails plus bio and follower counts from SoundCloud profiles |
| [Substack Profile Email Scraper](https://apify.com/leads-scraper/substack-profile-email-scraper) | Emails plus bio and follower counts from Substack profiles |
| [Telegram Profile Email Scraper](https://apify.com/leads-scraper/telegram-profile-email-scraper) | Emails plus bio and follower counts from Telegram profiles |
| [Threads Profile Email Scraper](https://apify.com/leads-scraper/threads-profile-email-scraper) | Emails plus bio and follower counts from Threads profiles |
| [TikTok Profile Email Scraper](https://apify.com/leads-scraper/tiktok-profile-email-scraper) | Emails plus bio and follower counts from TikTok profiles |
| [Tumblr Profile Email Scraper](https://apify.com/leads-scraper/tumblr-profile-email-scraper) | Emails plus bio and follower counts from Tumblr profiles |
| [Twitch Profile Email Scraper](https://apify.com/leads-scraper/twitch-profile-email-scraper) | Emails plus bio and follower counts from Twitch profiles |
| [X Profile Email Scraper](https://apify.com/leads-scraper/x-profile-email-scraper) | Emails plus bio and follower counts from X profiles |
| [YouTube Profile Email Scraper](https://apify.com/leads-scraper/youtube-profile-email-scraper) | Emails plus bio and follower counts from YouTube profiles |
| [Behance Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/behance-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Behance |
| [Bluesky Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/bluesky-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Bluesky |
| [Buy Me a Coffee Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Buy Me a Coffee |
| [DEV Community Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DEV Community |
| [DeviantArt Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/deviantart-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DeviantArt |
| [Dribbble Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/dribbble-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Dribbble |
| [Facebook Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/facebook-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Facebook |
| [Flipboard Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Flipboard |
| [GitHub Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/github-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitHub |
| [Gumroad Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/gumroad-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Gumroad |
| [Hashnode Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/hashnode-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Hashnode |

### Support for the GitLab Profile Email Scraper

Questions about the GitLab Profile Email Scraper, bug reports, field requests or a custom build —
email <neurodata.apify@gmail.com>.

Include the run ID and the input you used. If a GitLab layout change breaks a field, report it and
it gets fixed: the regex-first cascade survives most front-end changes, but not all of them.

### Leave a review

If the GitLab Profile 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.

# Actor input Schema

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

Search terms - a niche, job title or industry. The Actor finds GitLab 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 GitLab profile URLs, e.g. `https://gitlab.com/username`. Bare usernames also work. Use this when you already know which accounts you want.

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

GitLab 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. Leave EMPTY (recommended) to search the 12 biggest free-mail providers - Gmail, Yahoo, Outlook, Hotmail, iCloud, AOL, Proton, Live, GMX, Mail.com, Yandex and Zoho - and keep every address found, including company domains. Listing domains here narrows the search to only those.

## `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": [
    "developer",
    "maintainer"
  ],
  "location": "",
  "profileUrls": [],
  "usernames": [],
  "customDomains": [],
  "onlyWithEmail": false,
  "maxProfiles": 100,
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "maintainer",
    "author",
    "support"
  ],
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": ""
}
```

# Actor output Schema

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

Records produced by GitLab 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": [
        "developer",
        "maintainer"
    ],
    "location": "",
    "countryCode": ""
};

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

# Run the Actor and wait for it to finish
run = client.actor("neuro-scraper/gitlab-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": [
    "developer",
    "maintainer"
  ],
  "location": "",
  "countryCode": ""
}' |
apify call neuro-scraper/gitlab-profile-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-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/YHMZ5ffGh8lUxmJo4/builds/uiya7fYsMEpANI4JJ/openapi.json