# GitLab Projects Scraper - Open Source Repos, Stars & Topics (`scrapers_lat/gitlab-projects-scraper`) Actor

Scrape public GitLab.com projects by keyword, topic or path with stars, forks, topics, activity, namespace and web URL. Optional language breakdown, license and latest release. JSON, CSV, Excel.

- **URL**: https://apify.com/scrapers\_lat/gitlab-projects-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 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 Projects Scraper - Open Source Repos, Stars & Topics](https://scrapers.lat/banners/gitlab-projects-scraper.png)](https://apify.com/scrapers_lat/gitlab-projects-scraper)

## GitLab Projects Scraper - Open Source Repos, Stars & Topics

Here is one real result, with every field the actor returns:

```json
{
  "id": 250833,
  "name": "gitlab-runner",
  "pathWithNamespace": "gitlab-org/gitlab-runner",
  "namespace": "GitLab.org",
  "namespaceKind": "group",
  "namespaceFullPath": "gitlab-org",
  "description": "GitLab Runner is the open source project that is used to run your CI/CD jobs and send the results back to GitLab",
  "starCount": 2569,
  "forksCount": 2646,
  "openIssuesCount": null,
  "topics": ["golang", "hacktoberfest"],
  "createdAt": "2015-04-27T21:10:25.322Z",
  "lastActivityAt": "2026-08-17T07:48:29.709Z",
  "defaultBranch": "main",
  "webUrl": "https://gitlab.com/gitlab-org/gitlab-runner",
  "avatarUrl": "https://gitlab.com/uploads/-/system/project/avatar/250833/runner.png",
  "readmeUrl": "https://gitlab.com/gitlab-org/gitlab-runner/-/blob/main/README.md",
  "visibility": "public",
  "languageBreakdown": { "Go": 98.33, "Shell": 0.87, "Makefile": 0.49, "HCL": 0.14, "PowerShell": 0.07 },
  "primaryLanguage": "Go",
  "license": "MIT License",
  "latestReleaseTag": "v19.2.2",
  "latestReleaseName": "v19.2.2",
  "latestReleaseAt": "2026-08-13T15:31:29.907Z",
  "aiWhatItDoes": "GitLab Runner is an open-source tool that executes CI/CD jobs and reports the results back to GitLab, facilitating continuous integration and deployment workflows.",
  "aiCategory": "CI/CD",
  "aiTechStack": ["Go", "Shell", "Makefile", "HCL", "PowerShell"],
  "aiTargetUser": "Developers and DevOps teams looking to automate their software development processes.",
  "source": "GitLab",
  "observedAt": "2026-08-17T08:24:29.811Z",
  "error": null
}
```

The most complete GitLab.com projects scraper available. It browses or searches public projects and returns every listing field GitLab exposes, including stars, forks, open issues, topics, namespace, activity and web URL, plus optional add-ons that enrich each project with its full language breakdown, license and latest release, and an AI summary of what the project does. Complements our GitHub Repositories Scraper by covering the GitLab ecosystem.

**📥 [Input](https://apify.com/scrapers_lat/gitlab-projects-scraper/input-schema) · 📤 [Output](https://apify.com/scrapers_lat/gitlab-projects-scraper/output-schema) · 💰 [Pricing](https://apify.com/scrapers_lat/gitlab-projects-scraper/pricing) · ▶️ [Examples](https://apify.com/scrapers_lat/gitlab-projects-scraper/examples)**

![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify\&logoColor=white)
![Coverage](https://img.shields.io/badge/Coverage-GitLab.com-fc6d26)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)
![Billing](https://img.shields.io/badge/Billing-Pay%20per%20result-brightgreen)

### Table of contents

- [What it does](#what-it-does)
- [Use cases](#use-cases)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing-and-limits)
- [FAQ and troubleshooting](#faq-and-troubleshooting)

### What it does

The actor browses or searches public projects on GitLab.com and writes one normalized record per project to the run's dataset. Each record carries the project metadata (stars, forks, open issues, topics, namespace, default branch, activity timestamps and web URL). Optional paid add-ons fetch the project's language breakdown, license and latest release, and write an AI summary describing what the project does, its category, tech stack and target user.

Three ways to find projects:

- **Browse** the most popular public projects, sorted by stars, last activity or creation date.
- **Search** project names and descriptions by keyword, optionally filtered by topic.
- **Project** lookups by exact `namespace/project` path for a known list of repositories.

Data covers only what GitLab exposes publicly. Fields a project keeps private or has disabled (for example releases on a project with releases turned off) are returned as `null`; the actor never invents a value.

### Use cases

- **OSS intelligence.** Track the open-source projects, tooling and communities that live on GitLab rather than GitHub, with stars, forks and activity as adoption signals.
- **Developer tools and market research.** Map competing projects in a category, watch topic ecosystems (devops, kubernetes, rust) and benchmark popularity and release cadence.
- **Dependency and supply-chain tracking.** Monitor specific `namespace/project` paths for latest release tags, license changes and activity so you know when an upstream dependency moves.
- **Recruiting and developer sourcing.** Discover active maintainers and groups behind popular projects in a language or topic, with links straight to each project and namespace.

### Quickstart

Open the actor, paste this into the input, and press Run. It returns the top 5 most-starred public GitLab projects.

```json
{
  "mode": "browse",
  "sort": "stars",
  "maxResults": 5
}
```

Search a topic with full enrichment:

```json
{
  "mode": "search",
  "query": "kubernetes",
  "sort": "stars",
  "maxResults": 25,
  "includeDetails": true,
  "withAiSummary": true
}
```

### Input reference

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string | no | `browse` | `browse` lists top public projects, `search` filters by keyword/topic, `project` looks up specific paths. |
| `query` | string | no | | Keyword to search project names and descriptions (search mode). |
| `topic` | string | no | | Filter projects by a GitLab topic/tag, for example `devops`. |
| `sort` | string | no | `stars` | Order results by `stars`, `activity` (last updated) or `created` (newest). |
| `minStars` | integer | no | `0` | Only keep projects with at least this many stars. |
| `projectPaths` | string\[] | no | | Specific projects to look up as `namespace/project` (project mode). |
| `maxResults` | integer | no | `25` | Maximum number of projects to collect. |
| `includeDetails` | boolean | no | `false` | Paid add-on. Adds language breakdown, license and latest release per project. Charged per project enriched. |
| `withAiSummary` | boolean | no | `false` | Paid add-on. Adds an AI summary, category, tech stack and target user per project. Charged per project summarised. |

Paid add-ons are disabled for free (non-paying) Apify users.

### Output reference

One dataset item per project. Types: `string`, `integer`, `object`, `string[]`, or `null` when the source value is absent.

| Field | Type | Description |
|---|---|---|
| `id` | integer | GitLab numeric project ID. |
| `name` | string | Project name. |
| `pathWithNamespace` | string | `namespace/project` identifier. |
| `namespace` | string | Namespace (group or user) display name. |
| `namespaceKind` | string | `group` or `user`. |
| `namespaceFullPath` | string | Full namespace path. |
| `description` | string | Project description, or `null`. |
| `starCount` | integer | Star count. |
| `forksCount` | integer | Fork count. |
| `openIssuesCount` | integer | Open issues count, or `null` when disabled. |
| `topics` | string\[] | Project topics/tags set by the owner. |
| `createdAt` | string | ISO 8601 creation timestamp. |
| `lastActivityAt` | string | ISO 8601 last-activity timestamp. |
| `defaultBranch` | string | Default branch name. |
| `webUrl` | string | Canonical project URL. |
| `avatarUrl` | string | Project avatar image URL, or `null`. |
| `readmeUrl` | string | README URL, or `null`. |
| `visibility` | string | Project visibility, always `public`. |
| `languageBreakdown` | object | Details add-on. Map of language to percent. |
| `primaryLanguage` | string | Details add-on. Highest-percentage language. |
| `license` | string | Details add-on. License name, or `null`. |
| `latestReleaseTag` | string | Details add-on. Latest release tag, or `null`. |
| `latestReleaseName` | string | Details add-on. Latest release name, or `null`. |
| `latestReleaseAt` | string | Details add-on. Latest release date, or `null`. |
| `aiWhatItDoes` | string | AI add-on. Plain-English summary of the project. |
| `aiCategory` | string | AI add-on. Normalized category label. |
| `aiTechStack` | string\[] | AI add-on. Inferred tech stack. |
| `aiTargetUser` | string | AI add-on. Who the project is for. |
| `source` | string | Always `GitLab`. |
| `observedAt` | string | ISO 8601 timestamp of when the record was collected. |
| `error` | string | Present only on a failed lookup, where an item with a populated `error` field is written instead. |

### Run via API and CLI

Start a run and wait for it to finish, then read the dataset. Replace `<TOKEN>` with your Apify API token.

Run synchronously and get dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~gitlab-projects-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","query":"kubernetes","maxResults":25}'
```

Start a run asynchronously:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~gitlab-projects-scraper/runs?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"browse","sort":"stars","maxResults":100,"includeDetails":true}'
```

Apify CLI:

```bash
apify call scrapers_lat/gitlab-projects-scraper \
  --input '{"mode":"project","projectPaths":["gitlab-org/gitlab-runner"],"includeDetails":true}'
```

### Fetch results

Every run writes to a dataset. Fetch items as JSON, CSV, or Excel by changing `format`:

```bash
## JSON
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=json"

## CSV
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=csv"

## Paginate large datasets
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&offset=1000&limit=1000"
```

`<DATASET_ID>` is returned as `defaultDatasetId` in the run object. Use `offset` and `limit` to page through large result sets. `clean=true` drops empty and internal fields.

### Billing and limits

- **Pay per result.** You are charged per project returned (`result` event). See the [pricing tab](https://apify.com/scrapers_lat/gitlab-projects-scraper/pricing) for the current per-result price.
- **Details add-on.** The `details` event (`includeDetails`) is billed once per project only when the language breakdown, license or latest release is genuinely returned.
- **AI add-on.** The `ai_summary` event (`withAiSummary`) is billed per project only when a usable AI summary is produced.
- **No charge on failure.** If a lookup errors, the actor writes an item with a populated `error` field and does not charge for it. Empty runs cost nothing.
- **Spend cap respected.** Set `maxTotalChargeUsd` on the run; once reached, the actor stops emitting and charging further billable results and add-ons.
- **Free Apify plans** are capped at 10 projects per run and cannot use the paid add-ons. Upgrade for higher `maxResults` and enrichment.

### FAQ and troubleshooting

**A run returned 0 records. Why?**
The browse or search filter matched nothing. Loosen the `query`, drop the `topic` or lower `minStars`. Zero-result runs are not charged.

**How do I look up specific projects?**
Set `mode` to `project` and pass `projectPaths` as a list of `namespace/project` strings, for example `gitlab-org/gitlab-runner`. Each path is resolved individually and a bad path returns an `error` row without a charge.

**Why is `latestReleaseTag` null on some projects?**
GitLab lets a project disable its releases feature. When releases are off or a project has none, the field is `null`. Languages and license are still returned when available.

**What do the add-ons cost me?**
`includeDetails` adds language, license and release data and is billed per project enriched. `withAiSummary` adds an AI description and is billed per project summarised. Both require a paid Apify plan and are billed only when they produce data.

**Is this an official GitLab tool?**
No. This actor is independent and has no affiliation with GitLab. It reads only data that is publicly available through GitLab.com. Use it in accordance with GitLab's terms of service.

### Related scrapers

- [GitHub Repositories Scraper](https://apify.com/scrapers_lat/github-repositories-scraper): GitHub repositories with stars, forks, topics and owner contacts.
- [GitHub Contributor Contacts Scraper](https://apify.com/scrapers_lat/github-contributor-contacts-scraper): Top contributors and developer emails per repo.
- [npm Packages Scraper](https://apify.com/scrapers_lat/npm-packages-scraper): npm package metadata and maintainers.
- [Docker Hub Images Scraper](https://apify.com/scrapers_lat/dockerhub-images-scraper): Docker Hub image metadata and pull stats.
- [Crates.io Rust Packages Scraper](https://apify.com/scrapers_lat/crates-io-scraper): Rust crate metadata from crates.io.

# Actor input Schema

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

How to find projects. 'browse' lists top public projects, 'search' filters by keyword/topic, 'project' looks up specific projects by path.

## `query` (type: `string`):

Keyword to search project names and descriptions (used in search mode). Example: 'kubernetes'.

## `topic` (type: `string`):

Filter projects by a GitLab topic/tag. Example: 'devops'.

## `sort` (type: `string`):

Order results by star count, last activity, or creation date.

## `minStars` (type: `integer`):

Only keep projects with at least this many stars (client-side filter). Optional.

## `projectPaths` (type: `array`):

Specific projects to look up, as namespace/project (for example 'gitlab-org/gitlab-runner'). Used in project mode.

## `maxResults` (type: `integer`):

Maximum number of projects to collect. Free Apify plans are capped at 10 per run.

## `includeDetails` (type: `boolean`):

Opt-in. For each project, fetch its language breakdown, license, and latest release (tag + date). Charged per project only when extra data is returned. Requires a paid Apify plan.

## `withAiSummary` (type: `boolean`):

Opt-in. Adds an AI summary of what each project does, its category, tech stack and target user, from its name, description, topics and languages. Charged per project only when a summary is produced. Requires a paid Apify plan.

## Actor input object example

```json
{
  "mode": "browse",
  "sort": "stars",
  "maxResults": 25,
  "includeDetails": false,
  "withAiSummary": false
}
```

# Actor output Schema

## `results` (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 = {
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/gitlab-projects-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 = { "maxResults": 25 }

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/gitlab-projects-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 '{
  "maxResults": 25
}' |
apify call scrapers_lat/gitlab-projects-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/gitlab-projects-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/jCEuGh0dGWVwMvsnM/builds/O8OYq1X3c4F1WEOXB/openapi.json