# GitHub Repo Scraper (`devilscrapes/github-repo-scraper`) Actor

Fetch full GitHub repository metadata for one or many repos in one call — stars, forks, languages, topics, license, default branch, latest release, contributor count — export to JSON or CSV. A GitHub repo API wrapper; optional token for higher rate limits.

- **URL**: https://apify.com/devilscrapes/github-repo-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## GitHub Repo Scraper — Stars, Forks & Metadata

▶️ **[Watch the 45-second demo on YouTube](https://youtube.com/shorts/8Ukd46P1G_k)**

**💰 $2.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Point this GitHub repo scraper at any list of `owner/repo` slugs and get back a clean dataset row per repository — stars, forks, watchers, languages, topics, license, default branch, latest release tag, and contributor count. Built to handle GitHub's rate limits and secondary-rate-limit retries without breaking a sweat.

</div>

---

### 🎯 What this scrapes

GitHub exposes public repository data through its REST API, but turning a list of repos into a reliable dataset is messier than it looks: secondary-rate-limit errors kick in at burst speeds, the languages and release endpoints are separate calls, and unauthenticated requests cap out at 60 per hour. This GitHub repo scraper fans out requests in parallel, handles the retry dance automatically, and delivers one richly-typed row per repository — covering everything from `stargazers_count` through `latest_release_tag` to `scraped_at`.

Give it a list of `owner/repo` slugs or full GitHub URLs. It writes clean, Pydantic-validated rows straight into your Apify dataset. Use it for competitor benchmarking, OSS health checks, DevRel dashboards, AI/RAG corpus building, or any workflow that needs bulk GitHub repository data on demand.

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Chrome / Firefox / Safari TLS handshakes so requests look like a browser, not a Python script.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP whenever the target pushes back.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per request, `Retry-After` headers honoured.
- 🧱 **Rate-limit-aware pacing** — when GitHub's secondary rate limit kicks in, we slow down and wait rather than hammering until banned.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable field names, JSON / CSV / Excel export straight from Apify Console.
- 💰 **Pay-Per-Event pricing** — you pay only for results that land in your dataset. No data, no charge.

### 💡 Use cases

- **Competitor OSS benchmarking** — track stars and forks across rival projects week-over-week and pipe deltas to Slack or a BI tool.
- **Dependency health monitoring** — feed your stack's transitive repo list and flag anything archived, disabled, or unmaintained.
- **RAG corpus building** — pull language breakdowns and README metadata for a curated set of repos to seed a vector store.
- **Hiring and M&A research** — quantify the open-source surface area of a target company or candidate's personal GitHub activity.
- **Newsletter automation** — ingest a curated list weekly, diff the star counts, surface the fastest movers.
- **DevRel dashboards** — track your own org's repos alongside ecosystem repos in one unified dataset.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page — no credit card required.
2. Paste one or more `owner/repo` slugs (or full GitHub URLs) into the **repos** field.
3. Optionally add a GitHub Personal Access Token to lift the rate limit from 60 req/hr to 5 000 req/hr.
4. Click **Start**. Output streams into the run's dataset in real time.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or pull via the Apify API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `repos` | `array` | **yes** | `["apify/apify-sdk-python", "apify/crawlee-python"]` | List of repos as `owner/repo` slugs or full GitHub URLs. |
| `githubToken` | `string` | no | — | Personal access token. Unauthenticated = 60 req/hr; with token = 5 000 req/hr. Read-only `public_repo` scope is sufficient. |
| `includeLanguages` | `boolean` | no | `true` | Adds a `languages` map (language → bytes) per repo. One extra API call per repo. |
| `includeLatestRelease` | `boolean` | no | `true` | Adds `latest_release_tag` and `latest_release_published_at`. One extra API call per repo. |
| `concurrency` | `integer` | no | `6` | Parallel API requests. Up to 8 with a token; 2–3 without. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": false}` | Apify Proxy settings. Proxy is optional for the GitHub REST API — enable it if your network routing requires it. |

#### Example input

```json
{
  "repos": [
    "apify/apify-sdk-python",
    "apify/crawlee-python"
  ],
  "githubToken": "",
  "includeLanguages": true,
  "includeLatestRelease": true,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output

Every row is one dataset item representing one GitHub repository.

| Field | Type | Notes |
|---|---|---|
| `owner` | `string` | Owner or organisation login. |
| `name` | `string` | Repository name (without owner prefix). |
| `full_name` | `string` | Full slug — `owner/name`. |
| `html_url` | `string` | Canonical GitHub URL. |
| `description` | `string \| null` | Repository tagline. |
| `fork` | `boolean` | `true` if this is a fork. |
| `archived` | `boolean` | `true` if the repo is archived (read-only). |
| `disabled` | `boolean` | `true` if the repo is disabled. |
| `stargazers_count` | `integer` | Star count at scrape time. |
| `forks_count` | `integer` | Fork count. |
| `watchers_count` | `integer` | Watcher count (subscribers). |
| `open_issues_count` | `integer` | Open issues + open PRs combined. |
| `size_kb` | `integer` | Repository size in kilobytes. |
| `language` | `string \| null` | Primary language (GitHub's classification). |
| `languages` | `object \| null` | Map of language → bytes. Populated when `includeLanguages=true`. |
| `topics` | `array` | Repository topics / tags. |
| `license` | `string \| null` | SPDX identifier (e.g. `MIT`, `Apache-2.0`). |
| `default_branch` | `string` | Default branch name (usually `main`). |
| `homepage` | `string \| null` | User-supplied homepage URL. |
| `created_at` | `string` | Repo creation timestamp (ISO-8601 UTC). |
| `updated_at` | `string` | Last metadata update timestamp (ISO-8601 UTC). |
| `pushed_at` | `string` | Last commit push timestamp (ISO-8601 UTC). |
| `latest_release_tag` | `string \| null` | Tag of the latest GitHub release. Populated when `includeLatestRelease=true`. |
| `latest_release_published_at` | `string \| null` | Publish timestamp of the latest release (ISO-8601 UTC). |
| `scraped_at` | `string` | When this row was recorded (ISO-8601 UTC). |

#### Example output

```json
{
  "owner": "apify",
  "name": "apify-sdk-python",
  "full_name": "apify/apify-sdk-python",
  "html_url": "https://github.com/apify/apify-sdk-python",
  "description": "The Apify SDK for Python.",
  "fork": false,
  "archived": false,
  "stargazers_count": 415,
  "forks_count": 41,
  "watchers_count": 415,
  "open_issues_count": 12,
  "size_kb": 2048,
  "language": "Python",
  "languages": {
    "Python": 198432,
    "Shell": 1024
  },
  "topics": ["apify", "scraping", "sdk"],
  "license": "Apache-2.0",
  "default_branch": "main",
  "homepage": "https://docs.apify.com/sdk/python",
  "created_at": "2022-08-01T10:00:00Z",
  "updated_at": "2026-05-30T14:22:00Z",
  "pushed_at": "2026-05-29T08:11:00Z",
  "latest_release_tag": "v3.4.0",
  "latest_release_published_at": "2026-05-20T12:00:00Z",
  "scraped_at": "2026-06-01T09:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you only pay when these events fire:

| Event | USD | What triggers it |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.002 | Per dataset row written |

Example: 1 000 repos at the rates above ≈ **$2.00**. No subscription, no minimum, no card required to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

- **Private repos** require a token with the matching scopes — this Actor only processes repos the token can read. Do not reuse production tokens here.
- **README content, raw code, commit graphs, and pull request history** are outside the scope of this Actor. Use GitHub's search API or a dedicated commits scraper for those.
- **Large orgs** with thousands of repos will hit the 5 000 req/hr authenticated ceiling on long runs. Plan batches or spread runs over multiple hours.
- **GitHub caches some counts** (stars, forks) for a few minutes. Compare runs at least 5 minutes apart to catch real movement.

### ❓ FAQ

**Do I need a GitHub token?**

For small batches (under ~50 repos), no. The unauthenticated GitHub REST API allows 60 requests per hour, which is enough for a quick test. Provide a Personal Access Token to raise that ceiling to 5 000 requests per hour — `public_repo` read-only scope is all you need.

**Is this a GitHub REST API alternative or replacement?**

Neither — it is a wrapper that handles authentication, pagination, sub-resource fetching, secondary-rate-limit retries, and structured output so you do not have to write that code yourself. The GitHub API still powers the requests; we handle the operational layer on top of it.

**Can I use this to fetch github repo metadata api-style for hundreds of repos at once?**

Yes. This is the primary use case — pass a list of hundreds of `owner/repo` slugs, set your token, and the Actor fans them out in parallel while respecting GitHub's rate limits. Output lands in a clean dataset ready to export or query.

**How is this different from calling the GitHub REST API myself?**

Writing a reliable github repository scraper yourself means handling secondary rate limits, separate language and release endpoints, pagination, token rotation, and structured output validation. That is 1–2 dev-weeks of plumbing. This Actor handles all of it for $2 per 1 000 repos.

**What if a repo doesn't exist or has been deleted?**

The Actor logs a warning for that slug and continues — the rest of your list still processes normally. You get a partial dataset with a clear log entry for every skipped repo.

**Can I scrape private repositories?**

You can — if you supply a token that has access to those repos. This Actor was designed for bulk public-data extraction; do not use production tokens here.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new output field? Open an issue on the Actor's **Issues** tab in Apify Console — we read every report and ship fixes weekly.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `repos` (type: `array`):

List of repos in <code>owner/repo</code> form (e.g. <code>apify/apify-sdk-python</code>) or as full GitHub URLs. Each input becomes one dataset row.

## `githubToken` (type: `string`):

Personal access token. Without one you get 60 requests/hour; with one, 5 000/hour. Read-only access to public repos is sufficient (no scopes needed).

## `includeLanguages` (type: `boolean`):

Adds a `languages` map (language → bytes) per repo. One extra API call per repo.

## `includeLatestRelease` (type: `boolean`):

Adds `latest_release_tag` and `latest_release_published_at`. One extra API call per repo.

## `concurrency` (type: `integer`):

Parallel API requests. 8 is comfortable with a token; 2-3 without.

## `proxyConfiguration` (type: `object`):

Apify Proxy is optional — the GitHub API does not block based on IP. Use proxy only if your enterprise routing requires it.

## Actor input object example

```json
{
  "repos": [
    "apify/apify-sdk-python",
    "apify/crawlee-python"
  ],
  "includeLanguages": true,
  "includeLatestRelease": true,
  "concurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "repos": [
        "apify/apify-sdk-python",
        "apify/crawlee-python"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/github-repo-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 = {
    "repos": [
        "apify/apify-sdk-python",
        "apify/crawlee-python",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/github-repo-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 '{
  "repos": [
    "apify/apify-sdk-python",
    "apify/crawlee-python"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call devilscrapes/github-repo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Repo Scraper",
        "description": "Fetch full GitHub repository metadata for one or many repos in one call — stars, forks, languages, topics, license, default branch, latest release, contributor count — export to JSON or CSV. A GitHub repo API wrapper; optional token for higher rate limits.",
        "version": "0.4",
        "x-build-id": "mClkAS8loiU2eQsfk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~github-repo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-github-repo-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/devilscrapes~github-repo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-github-repo-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/devilscrapes~github-repo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-github-repo-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",
                "required": [
                    "repos"
                ],
                "properties": {
                    "repos": {
                        "title": "Repositories",
                        "type": "array",
                        "description": "List of repos in <code>owner/repo</code> form (e.g. <code>apify/apify-sdk-python</code>) or as full GitHub URLs. Each input becomes one dataset row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "githubToken": {
                        "title": "GitHub token (optional)",
                        "type": "string",
                        "description": "Personal access token. Without one you get 60 requests/hour; with one, 5 000/hour. Read-only access to public repos is sufficient (no scopes needed)."
                    },
                    "includeLanguages": {
                        "title": "Include language breakdown",
                        "type": "boolean",
                        "description": "Adds a `languages` map (language → bytes) per repo. One extra API call per repo.",
                        "default": true
                    },
                    "includeLatestRelease": {
                        "title": "Include latest release",
                        "type": "boolean",
                        "description": "Adds `latest_release_tag` and `latest_release_published_at`. One extra API call per repo.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrent fetches",
                        "minimum": 1,
                        "maximum": 32,
                        "type": "integer",
                        "description": "Parallel API requests. 8 is comfortable with a token; 2-3 without.",
                        "default": 6
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is optional — the GitHub API does not block based on IP. Use proxy only if your enterprise routing requires it.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```