# GitLab Jobs & Companies Scraper (`crawlerbros/gitlab-jobs-companies-scraper`) Actor

Scrape public GitLab job listings and company-careers profile data from GitLab's live Greenhouse board

- **URL**: https://apify.com/crawlerbros/gitlab-jobs-companies-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Jobs & Companies Scraper

Scrape public GitLab hiring data from GitLab's live Greenhouse job board and careers site. This actor returns real GitLab job postings with titles, locations, departments, requisition IDs, publish/update timestamps, full descriptions, and a lightweight GitLab company profile mode.

Use it for:
- hiring intelligence and recruiting research
- monitoring GitLab openings by department or quota coverage type
- collecting direct apply URLs for live jobs
- tracking GitLab careers content without logging in

### What This Actor Scrapes

#### Job records
- job title
- direct Greenhouse apply URL
- GitLab company name
- location string
- requisition ID and internal job ID
- publish time and update time
- application deadline when present
- department names
- office names
- quota coverage type
- full description HTML and plain text
- section headings and outbound links found in the description

#### Company profile record
- GitLab careers URL
- GitLab benefits URL
- GitLab values URL
- GitLab handbook URL
- remote-company indicator
- intro paragraphs and section headings from the careers page

### Input

#### Modes

- `searchJobs`: Search GitLab jobs by keyword across title, company, location, and requisition ID.
- `allJobs`: Return public GitLab jobs without requiring a search query.
- `byDepartment`: Return jobs matching one or more GitLab departments.
- `byJobIds`: Resolve exact Greenhouse job IDs.
- `byJobUrls`: Resolve exact GitLab Greenhouse job URLs.
- `companyProfile`: Return a single GitLab company-profile record from the public careers page.

#### Main inputs

- `searchQuery`: Keyword for `searchJobs`
- `departmentNames`: Exact GitLab departments
- `quotaCoverageTypes`: Exact GitLab quota coverage values
- `jobIds`: Exact Greenhouse job IDs
- `jobUrls`: Exact Greenhouse job URLs
- `locationContains`: Case-insensitive location substring filter
- `publishedFrom`: Keep jobs first published on or after this ISO date/time
- `updatedFrom`: Keep jobs updated on or after this ISO date/time
- `sortBy`: Sort order for list modes
- `fetchFullDescription`: Include full detail fields and description text
- `maxItems`: Maximum records to return

### Output

The actor emits either `job`, `company`, or `error` records.

#### Example job record

```json
{
  "recordType": "job",
  "jobId": "8503792002",
  "url": "https://job-boards.greenhouse.io/gitlab/jobs/8503792002",
  "title": "Account Executive - Italy",
  "companyName": "GitLab",
  "location": "Remote",
  "language": "en",
  "requisitionId": "6263",
  "internalJobId": "6396658002",
  "firstPublishedAt": "2026-04-17T09:58:03+00:00",
  "updatedAt": "2026-04-30T22:34:50+00:00",
  "quotaCoverageType": "Account Executive",
  "departmentNames": ["AMER - Commercial"],
  "descriptionText": "GitLab is the intelligent orchestration platform for DevSecOps ...",
  "scrapedAt": "2026-05-14T10:00:00+00:00"
}
````

### Notes

- This actor uses public GitLab and Greenhouse endpoints only.
- No cookies, login, or API key are required.
- GitLab's public job board is remote-heavy, so many records use remote location strings.
- Invalid lookup inputs return typed `error` records instead of failing silently.

### Daily Test

The default prefill uses a broad live GitLab search that should always return real job data:

```json
{
  "mode": "searchJobs",
  "searchQuery": "engineer",
  "maxItems": 5
}
```

# Actor input Schema

## `mode` (type: `string`):

Choose how to collect GitLab data.

## `searchQuery` (type: `string`):

Keyword used by searchJobs mode. Matches job title, company, location, and requisition ID.

## `departmentNames` (type: `array`):

Exact GitLab department names for byDepartment mode or as an additional filter. Known values: AMER - Commercial, Alliances and Channel, Architecture Engineering, Customer Experience, Customer Success, Data Engineering, DevOps Engineering, EMEA - Commercial, EMEA - Enterprise, Enablement, Enterprise Applications, Platforms, Platforms Engineering, Practice Management, Sales Development, Sec Engineering, Talent Acquisition, Technical Writing.

## `quotaCoverageTypes` (type: `array`):

Exact quota coverage values from GitLab's Greenhouse metadata. Known values: Account Executive, N/A, Overlay, Overlay Quota Rep (OQR).

## `jobIds` (type: `array`):

Exact Greenhouse job IDs for byJobIds mode.

## `jobUrls` (type: `array`):

Exact Greenhouse job URLs for byJobUrls mode.

## `locationContains` (type: `string`):

Optional case-insensitive location substring filter, for example Italy, Remote, EMEA, or US.

## `publishedFrom` (type: `string`):

Optional ISO date/time lower bound for firstPublishedAt.

## `updatedFrom` (type: `string`):

Optional ISO date/time lower bound for updatedAt.

## `sortBy` (type: `string`):

Sort order for job list modes.

## `fetchFullDescription` (type: `boolean`):

When enabled, fetches detail pages to include description text, departments, offices, and section headings.

## `maxItems` (type: `integer`):

Maximum records to emit.

## Actor input object example

```json
{
  "mode": "searchJobs",
  "searchQuery": "engineer",
  "departmentNames": [
    "Architecture Engineering"
  ],
  "quotaCoverageTypes": [],
  "sortBy": "firstPublishedDesc",
  "fetchFullDescription": true,
  "maxItems": 5
}
```

# Actor output Schema

## `items` (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 = {
    "mode": "searchJobs",
    "searchQuery": "engineer",
    "departmentNames": [
        "Architecture Engineering"
    ],
    "sortBy": "firstPublishedDesc",
    "fetchFullDescription": true,
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gitlab-jobs-companies-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 = {
    "mode": "searchJobs",
    "searchQuery": "engineer",
    "departmentNames": ["Architecture Engineering"],
    "sortBy": "firstPublishedDesc",
    "fetchFullDescription": True,
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gitlab-jobs-companies-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "searchJobs",
  "searchQuery": "engineer",
  "departmentNames": [
    "Architecture Engineering"
  ],
  "sortBy": "firstPublishedDesc",
  "fetchFullDescription": true,
  "maxItems": 5
}' |
apify call crawlerbros/gitlab-jobs-companies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/gitlab-jobs-companies-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitLab Jobs & Companies Scraper",
        "description": "Scrape public GitLab job listings and company-careers profile data from GitLab's live Greenhouse board",
        "version": "0.1",
        "x-build-id": "eaYBxmnZJcmwobUds"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gitlab-jobs-companies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gitlab-jobs-companies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~gitlab-jobs-companies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gitlab-jobs-companies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~gitlab-jobs-companies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gitlab-jobs-companies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchJobs",
                            "allJobs",
                            "byDepartment",
                            "byJobIds",
                            "byJobUrls",
                            "companyProfile"
                        ],
                        "type": "string",
                        "description": "Choose how to collect GitLab data.",
                        "default": "searchJobs"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword used by searchJobs mode. Matches job title, company, location, and requisition ID."
                    },
                    "departmentNames": {
                        "title": "Department Names",
                        "type": "array",
                        "description": "Exact GitLab department names for byDepartment mode or as an additional filter. Known values: AMER - Commercial, Alliances and Channel, Architecture Engineering, Customer Experience, Customer Success, Data Engineering, DevOps Engineering, EMEA - Commercial, EMEA - Enterprise, Enablement, Enterprise Applications, Platforms, Platforms Engineering, Practice Management, Sales Development, Sec Engineering, Talent Acquisition, Technical Writing.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "quotaCoverageTypes": {
                        "title": "Quota Coverage Types",
                        "type": "array",
                        "description": "Exact quota coverage values from GitLab's Greenhouse metadata. Known values: Account Executive, N/A, Overlay, Overlay Quota Rep (OQR).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobIds": {
                        "title": "Job IDs",
                        "type": "array",
                        "description": "Exact Greenhouse job IDs for byJobIds mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobUrls": {
                        "title": "Job URLs",
                        "type": "array",
                        "description": "Exact Greenhouse job URLs for byJobUrls mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationContains": {
                        "title": "Location Contains",
                        "type": "string",
                        "description": "Optional case-insensitive location substring filter, for example Italy, Remote, EMEA, or US."
                    },
                    "publishedFrom": {
                        "title": "Published From",
                        "type": "string",
                        "description": "Optional ISO date/time lower bound for firstPublishedAt."
                    },
                    "updatedFrom": {
                        "title": "Updated From",
                        "type": "string",
                        "description": "Optional ISO date/time lower bound for updatedAt."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "firstPublishedDesc",
                            "firstPublishedAsc",
                            "updatedDesc",
                            "updatedAsc",
                            "titleAsc",
                            "titleDesc"
                        ],
                        "type": "string",
                        "description": "Sort order for job list modes.",
                        "default": "firstPublishedDesc"
                    },
                    "fetchFullDescription": {
                        "title": "Fetch Full Description",
                        "type": "boolean",
                        "description": "When enabled, fetches detail pages to include description text, departments, offices, and section headings.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum records to emit.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
