GitLab Profile Email Scraper

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.

{
  "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 "":

{
  "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	Emails, phone numbers and profile details from GitLab
GitLab Profile Phone Number Scraper	Phone numbers plus bio and follower counts from GitLab profiles
Behance Profile Email Scraper	Emails plus bio and follower counts from Behance profiles
Bluesky Profile Email Scraper	Emails plus bio and follower counts from Bluesky profiles
Buy Me a Coffee Profile Email Scraper	Emails plus bio and follower counts from Buy Me a Coffee profiles
DEV Community Profile Email Scraper	Emails plus bio and follower counts from DEV Community profiles
DeviantArt Profile Email Scraper	Emails plus bio and follower counts from DeviantArt profiles
Dribbble Profile Email Scraper	Emails plus bio and follower counts from Dribbble profiles
Facebook Profile Email Scraper	Emails plus bio and follower counts from Facebook profiles
Flipboard Profile Email Scraper	Emails plus bio and follower counts from Flipboard profiles
GitHub Profile Email Scraper	Emails plus bio and follower counts from GitHub profiles
Gumroad Profile Email Scraper	Emails plus bio and follower counts from Gumroad profiles
Hashnode Profile Email Scraper	Emails plus bio and follower counts from Hashnode profiles
Hugging Face Profile Email Scraper	Emails plus bio and follower counts from Hugging Face profiles
Instagram Profile Email Scraper	Emails plus bio and follower counts from Instagram profiles
Kick Profile Email Scraper	Emails plus bio and follower counts from Kick profiles
Linktree Profile Email Scraper	Emails plus bio and follower counts from Linktree profiles
Mastodon Profile Email Scraper	Emails plus bio and follower counts from Mastodon profiles
Mixcloud Profile Email Scraper	Emails plus bio and follower counts from Mixcloud profiles
Patreon Profile Email Scraper	Emails plus bio and follower counts from Patreon profiles
Pinterest Profile Email Scraper	Emails plus bio and follower counts from Pinterest profiles
Snapchat Profile Email Scraper	Emails plus bio and follower counts from Snapchat profiles
SoundCloud Profile Email Scraper	Emails plus bio and follower counts from SoundCloud profiles
Substack Profile Email Scraper	Emails plus bio and follower counts from Substack profiles
Telegram Profile Email Scraper	Emails plus bio and follower counts from Telegram profiles
Threads Profile Email Scraper	Emails plus bio and follower counts from Threads profiles
TikTok Profile Email Scraper	Emails plus bio and follower counts from TikTok profiles
Tumblr Profile Email Scraper	Emails plus bio and follower counts from Tumblr profiles
Twitch Profile Email Scraper	Emails plus bio and follower counts from Twitch profiles
X Profile Email Scraper	Emails plus bio and follower counts from X profiles
YouTube Profile Email Scraper	Emails plus bio and follower counts from YouTube profiles
Behance Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from Behance
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	Emails, phone numbers and profile details from Buy Me a Coffee
DEV Community Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from DEV Community
DeviantArt Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from DeviantArt
Dribbble Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from Dribbble
Facebook Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from Facebook
Flipboard Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from Flipboard
GitHub Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from GitHub
Gumroad Profile Email and Phone Number Scraper	Emails, phone numbers and profile details from Gumroad
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.