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

GitLab Email Scraper finds publicly available email addresses from GitLab search results using custom keywords, locations, and email domains. Extract targeted contacts, filter unwanted terms, avoid duplicates, and export structured lead data to an Apify Dataset.

- **URL**: https://apify.com/email\_scraper/gitlab-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 🔍 **GitLab Email Scraper – Overview**

**GitLab Email Scraper** is an Apify Actor designed to find publicly listed email addresses associated with GitLab search results. It searches GitLab-related pages using the keywords, email-domain suffixes, and optional location you provide, then extracts matching email addresses into a structured Apify Dataset.

The Actor is useful for lead generation, B2B prospecting, contact discovery, market research, developer outreach, agency prospecting, and other workflows where publicly available GitLab contact information is relevant.

Instead of manually opening search results and checking profile descriptions one by one, **GitLab Email Scraper** lets you provide multiple search terms and email domains and collect matching contacts automatically.

> 📌 **GitLab Email Scraper at a glance**
>
> - Search GitLab results using custom keywords
> - Filter searches by country, city, state, or other location text
> - Search for specific email-domain suffixes
> - Extract email addresses from available search-result descriptions
> - Exclude unwanted words or phrases
> - Save structured results to an Apify Dataset
> - Remove duplicate email addresses during the run
> - Set a configurable maximum result target for each keyword + domain combination

***

### 🔹 **GitLab Email Scraper – Key Features**

**GitLab Email Scraper** combines flexible search inputs with structured email extraction, making it suitable for targeted contact discovery rather than a single fixed query.

#### ⚙️ **Flexible Keyword Search**

Provide one or many keywords or search queries. More specific keywords can help narrow the search toward the type of GitLab users or organizations you are trying to discover.

Examples include:

- Software Company
- Software Developer
- DevOps Engineer
- Python Developer
- Web Developer
- Open Source Developer

Using several related keywords can provide broader search coverage than relying on one generic term.

#### 🌍 **Location-Based Search**

The optional location input allows you to add a geographic term to the search.

Examples:

- United States
- New York
- London
- Toronto
- Germany
- Bangladesh

Leave the location empty when you want a broader search without a geographic keyword.

#### 📧 **Custom Email Domains**

You can specify the email-domain suffixes you want the Actor to search for.

Examples:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`
- A relevant company or organizational domain

This allows you to focus the search on the types of email addresses most useful to your workflow.

#### 🚫 **Exclude Words and Phrases**

The **excludeWords** filter helps remove search-result descriptions containing unwanted terms.

For example:

- crypto
- onlyfans
- gambling
- unrelated

Single-word matches are handled as whole words, while phrases are matched as phrases without requiring exact capitalization.

***

### 🔍 **GitLab Email Scraper – What Data Can You Extract?**

The **GitLab Email Scraper** produces structured contact records containing the search context, result information, and extracted email address.

> 📦 **Output / Data Fields**
>
> - **keyword** — The keyword used for the search
> - **title** — The title of the matching search result
> - **description** — The available search-result description or snippet
> - **url** — The URL associated with the result
> - **email** — The extracted email address matching the selected domain
>
> The Actor's configured Dataset view presents these fields in a table for easy inspection.

The extracted email is associated with the corresponding search result, giving you context around where the contact information was discovered.

Because extraction is based on publicly available search-result content, the Actor cannot guarantee that every GitLab page contains an email address or that every requested target will be available.

***

### 🛠️ **GitLab Email Scraper – How to Use It**

Using **GitLab Email Scraper** requires only a few basic inputs.

#### 1. 🔎 Enter Keywords

Add one or more targeted search terms to **keywords**.

For example:

```json
{
  "keywords": [
    "Software Company",
    "Software Developer",
    "DevOps Engineer"
  ]
}
```

Specific and varied search terms are generally more useful than repeating the same broad keyword.

#### 2. 🌍 Add a Location

Use **location** to narrow the search:

```json
{
  "location": "New York"
}
```

You can also leave it blank:

```json
{
  "location": ""
}
```

#### 3. 📧 Select Email Domains

Specify the email suffixes you want:

```json
{
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ]
}
```

#### 4. 🎯 Set the Maximum Email Target

Use **maxEmails** to control how many emails the Actor should aim to collect for each keyword + domain combination.

```json
{
  "maxEmails": 20
}
```

The input accepts values from **1 to 10,000**.

#### 5. 🚫 Add Exclusion Terms

To skip descriptions containing unwanted terms:

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

#### 6. ▶️ Run the Actor

After entering the inputs, start the Actor. The resulting records are pushed into the configured Apify Dataset as the search progresses.

***

### 🔎 **How to Extract GitLab Emails More Effectively**

The best way to use **GitLab Email Scraper** is to combine targeted keywords, multiple email domains, and an appropriate location strategy.

For example, rather than searching only:

```text
Developer
```

consider using a group of related searches:

```text
Software Developer
Python Developer
Web Developer
DevOps Engineer
Full Stack Developer
Software Company
Open Source Developer
```

You can then combine those searches with multiple domains.

> 💡 **Search strategy example**
>
> - 5 targeted keywords
> - 4 email domains
> - Optional location
> - A moderate **maxEmails** value
> - Exclusion terms for unwanted categories
>
> This creates multiple keyword + domain search combinations and can broaden the available contact coverage.

Results still depend on what publicly available information appears in search results, so a higher target does not guarantee that the requested number of emails will be found.

***

### 📊 **What Happens When Multiple Keywords and Domains Are Used?**

**GitLab Email Scraper** processes keyword and email-domain combinations independently.

For example, suppose you enter:

- 3 keywords
- 2 email domains
- `maxEmails = 20`

The Actor works through the resulting 6 combinations and aims for up to 20 email results for each combination.

This does **not** mean 120 unique emails are guaranteed. The Actor tracks previously found email addresses and avoids returning the same email repeatedly during the run.

> ✅ **Important**
>
> - `maxEmails` is a per keyword + domain target
> - Duplicate email addresses are skipped
> - Actual results depend on publicly available search data
> - A requested maximum is a target, not a guaranteed quantity

***

### 🧠 **GitLab Email Scraper – Use Cases**

**GitLab Email Scraper** can support several practical data-collection workflows.

#### 💼 **B2B Lead Generation**

Find publicly listed email addresses related to software companies, technical professionals, and other GitLab-focused searches.

#### 🤝 **Developer Outreach**

Use targeted technical keywords such as Python Developer, DevOps Engineer, or Web Developer to discover relevant publicly listed contact information.

#### 📣 **Agency Prospecting**

Digital agencies, development agencies, and service providers can search for relevant businesses or professional categories and organize potential contacts into a structured dataset.

#### 🔬 **Market Research**

Use combinations of keywords and locations to study where certain technical roles, companies, or software-related profiles appear in search results.

#### 🧩 **Niche Contact Discovery**

Custom email-domain inputs make it possible to focus on selected email providers or relevant organizational domains.

> 🎯 **Use Case Box**
>
> - Lead research
> - B2B prospecting
> - Developer outreach
> - Agency research
> - Market research
> - Contact discovery
> - Search-based data collection

***

### 📝 **GitLab Email Scraper – Input**

The Actor supports the following public input fields:

| Input             | Type    | Default                              | Description                                                      |
| ----------------- | ------- | ------------------------------------ | ---------------------------------------------------------------- |
| **keywords**      | Array   | Software Company, Software Developer | Search keywords or queries                                       |
| **location**      | String  | Empty                                | Optional country, state, city, or region                         |
| **customDomains** | Array   | `@gmail.com`                         | Email-domain suffixes to search for                              |
| **maxEmails**     | Integer | `10`                                 | Target per keyword + domain combination                          |
| **excludeWords**  | Array   | Empty                                | Words or phrases that cause a matching description to be skipped |

The **keywords** field is required. The other fields can be adjusted according to your search strategy.

> ⚙️ **Input Tips**
>
> - Use several related keywords for broader coverage
> - Use a location only when geographic targeting is important
> - Add multiple email domains when you want wider email coverage
> - Increase **maxEmails** when deeper collection is useful
> - Use **excludeWords** to remove unwanted categories

***

### 📦 **GitLab Email Scraper – Output Example**

A typical Dataset record follows this structure:

```json
{
  "keyword": "Software Developer",
  "title": "Example GitLab Result",
  "description": "Public search-result description containing example@gmail.com",
  "url": "https://gitlab.com/example",
  "email": "example@gmail.com"
}
```

The exact values depend on the search results available during your run.

The output is structured so you can inspect, filter, sort, or continue processing your collected contacts using the Dataset generated by the Actor.

***

### 💰 **GitLab Email Scraper – Pricing**

The Actor configuration contains a free-user result restriction of **100 emails maximum** when the free-tier limit applies.

For paid users, the Actor does not apply that specific free-tier ceiling.

Your selected **maxEmails** value still controls the requested collection target, subject to the Actor's available search results and duplicate filtering.

> 💡 **Pricing / Limit Note**
>
> - Free tier: up to **100 emails**
> - Paid users: free-tier result ceiling removed
> - `maxEmails`: configurable from **1 to 10,000**
> - Results are not guaranteed when the requested target exceeds publicly available matches

***

### ⚠️ **GitLab Email Scraper – Important Limitations**

There are several practical limitations to understand before running a large search.

First, the Actor depends on information visible in search-result descriptions. If an email address is not present in the available result content, it cannot be extracted.

Second, different keywords may return overlapping pages and email addresses. Duplicate email addresses are filtered so the same address is not repeatedly added to the collected result set.

Third, very narrow searches may return few useful results. Broader keywords, additional email domains, or a less restrictive location can improve discovery.

The Actor also stops searching when continued pagination is no longer producing useful new email results, helping avoid spending time on pages with little or no additional contact data.

***

### 🔄 **Can GitLab Email Scraper Resume Collection?**

Yes. **GitLab Email Scraper** maintains run progress so processing can continue from its stored position after an interruption.

Previously discovered email addresses are also tracked, which helps prevent duplicate collection during resumed processing.

This is useful for longer searches containing many keyword and domain combinations, where collecting everything in a single uninterrupted pass may not always be practical.

***

### 💡 **GitLab Email Scraper – Tips and Best Practices**

For higher-quality results, start with focused keywords that describe the people, companies, skills, or categories you actually want to research.

Avoid relying on one extremely broad search term. A collection of related phrases usually gives the Actor more search combinations to work with.

Use multiple domains when appropriate. For example, combining `@gmail.com`, `@yahoo.com`, and `@outlook.com` can broaden email-address discovery.

Location is best used when geographic relevance matters. When maximum overall coverage is more important, leaving the location empty gives the search fewer restrictions.

> 🚀 **Recommended workflow**
>
> - Start with 3–5 highly relevant keywords
> - Test a few email domains
> - Run a smaller **maxEmails** target first
> - Review the output quality
> - Add related keywords or broader locations when results are sparse
> - Use exclusion terms to remove unwanted categories

***

### ❓ **GitLab Email Scraper – Frequently Asked Questions**

#### 🔍 **What is GitLab Email Scraper?**

**GitLab Email Scraper** is an Apify Actor that searches for GitLab-related results using your keywords and extracts publicly available email addresses matching your selected email-domain suffixes.

#### 📧 **Can I search for Gmail emails from GitLab?**

Yes. The default email domain is `@gmail.com`, and you can add other domains such as `@yahoo.com` or `@outlook.com`.

#### 🌍 **Can I scrape GitLab emails by location?**

Yes. The optional **location** field can contain a city, state, country, or other geographic term used to narrow the search.

#### 🎯 **Does maxEmails mean the total emails for the entire run?**

No. The Actor processes the target independently for each keyword + domain combination. Duplicate email addresses may still reduce the total number of unique contacts collected.

#### 🚫 **Can I exclude certain words from results?**

Yes. Add words or phrases to **excludeWords**. When a matching term appears in a result description, that description is skipped for email extraction.

#### 📊 **What data does GitLab Email Scraper return?**

The configured Dataset contains **keyword, title, description, url, and email** fields.

#### 🔁 **Does the Actor remove duplicate emails?**

Yes. Previously discovered email addresses are tracked so duplicate email addresses are not collected repeatedly during the run.

#### 💯 **Will I always receive the exact number entered in maxEmails?**

No. **maxEmails** is a target. The actual number depends on the available search results, matching email domains, duplicate filtering, exclusions, and search coverage.

#### 🧩 **Can I use multiple keywords in one run?**

Yes. The **keywords** input is an array, so you can provide multiple search terms in the same Actor run.

#### 📈 **How can I improve GitLab email scraping results?**

Use multiple related keywords, add relevant email domains, avoid unnecessarily narrow locations, and test your search with a moderate result target before expanding it.

***

### 🛡️ **Privacy and Data Quality**

**GitLab Email Scraper** is designed to work with publicly discoverable search-result information. The quality and availability of extracted email addresses depend on what is publicly visible in the underlying search results.

Use collected contact information responsibly and make sure your outreach and data-processing activities comply with applicable laws, platform rules, and organizational policies.

***

### 🔧 **Support**

For Actor-related questions, improvements, custom requirements, or bespoke scraper development:

- contact me by email : <alphascraper69@gmail.com>

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

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

List of custom email domains

## `maxEmails` (type: `integer`):

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Software Company",
    "Software Developer"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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": [
        "Software Company",
        "Software Developer"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_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": [
        "Software Company",
        "Software Developer",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_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": [
    "Software Company",
    "Software Developer"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/gitlab-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_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/9Mkw4JANtDEUhKNkK/builds/mWx6FzgvYF7IrRE5M/openapi.json