# GitHub Contributor Email Scraper (`fetch_cat/github-contributor-email-scraper`) Actor

Extract public GitHub contributor commit emails, names, logins, commit URLs, dates, and repository context from repos or organizations.

- **URL**: https://apify.com/fetch\_cat/github-contributor-email-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 contributor email rows

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 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

## GitHub Contributor Email Scraper

Extract public GitHub contributor email rows from repository commit history.

### What does GitHub Contributor Email Scraper do?

GitHub Contributor Email Scraper collects public contributor contact and activity records from public GitHub repositories.

It reads public commit metadata and saves normalized rows with repository context, contributor name, public commit email, GitHub login when GitHub maps the commit to a profile, commit URL, commit date, and scrape timestamp.

Use it when you need a clean spreadsheet of public contributor email evidence instead of manually opening commits one by one.

### Who is it for?

- 🧑‍💻 Developer relations teams finding active open-source contributors.
- 🧲 Technical recruiters discovering engineers working in relevant repositories.
- 🧾 OSS program managers mapping contributor activity across projects.
- 🏢 B2B sales teams researching public technology ecosystems.
- 📊 Vendor intelligence teams tracking public project participation.
- 🧪 Researchers analyzing public software collaboration patterns.

### Why use it?

- GitHub-specific inputs for repositories and organizations.
- Public-only extraction from commit metadata.
- Optional GitHub token support for higher rate limits.
- Email deduplication across repositories.
- Noreply email filtering.
- Evidence links for every saved row.
- Ready-to-export dataset tables.

### What data can it extract?

| Field | Description |
| --- | --- |
| `repository` | Full `owner/repo` repository name. |
| `owner` | Repository owner login. |
| `repo` | Repository name. |
| `commitSha` | Commit SHA used as evidence. |
| `commitUrl` | GitHub commit URL. |
| `authorName` | Public commit author name. |
| `authorEmail` | Public commit author email. |
| `isNoreplyEmail` | Whether the email is a GitHub noreply address. |
| `githubLogin` | GitHub login when GitHub maps the commit to a profile. |
| `profileUrl` | GitHub profile URL when available. |
| `committedAt` | Commit author timestamp. |
| `messageSnippet` | Short commit message snippet. |
| `sourceType` | Repository or organization source mode. |
| `scrapedAt` | Timestamp when the row was collected. |

### How much does it cost to scrape GitHub contributor emails?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved contributor email row.
- Short test runs are inexpensive because you can set a low commit limit.
- Larger organization scans cost more because they inspect more repositories and commits.

Start with one repository and a small `maxCommitsPerRepo` value to estimate your cost and output quality.

### Input options

You can provide one or more of these sources:

- `repositoryUrls` — GitHub repository URLs such as `https://github.com/apify/crawlee`.
- `repositories` — compact `owner/repo` values such as `apify/crawlee`.
- `organization` — a GitHub organization login for scanning public organization repositories.

You can also set:

- `maxCommitsPerRepo`
- `since`
- `until`
- `includeNoreplyEmails`
- `dedupeByEmail`
- `githubToken`

### Example input

```json
{
  "repositoryUrls": [{ "url": "https://github.com/apify/crawlee" }],
  "maxCommitsPerRepo": 100,
  "includeNoreplyEmails": false,
  "dedupeByEmail": true
}
````

### Repository inputs

Repository URLs and `owner/repo` strings can be mixed in the same run.

Examples:

- `https://github.com/apify/crawlee`
- `https://github.com/apify/apify-sdk-js`
- `apify/crawlee`
- `apify/apify-sdk-js`

Invalid or non-GitHub URLs are ignored during normalization.

### Organization input

Set `organization` to scan public repositories from a GitHub organization.

For example:

```json
{
  "organization": "apify",
  "maxCommitsPerRepo": 25,
  "includeNoreplyEmails": false,
  "dedupeByEmail": true
}
```

Organization scans can produce many rows. Use smaller commit limits for your first run.

### Date filters

Use `since` and `until` to focus on a time window.

Examples:

- `2026-01-01`
- `2026-01-01T00:00:00Z`
- `2026-06-30T23:59:59Z`

Date filters are useful when you only need recent contributors.

### Noreply email filtering

GitHub users can hide their real email and commit with a noreply address.

Set `includeNoreplyEmails` to:

- `false` to focus on non-noreply public commit emails.
- `true` to include GitHub noreply addresses too.

The output includes `isNoreplyEmail` so you can filter exports later.

### Dedupe behavior

When `dedupeByEmail` is enabled, the actor saves only the first row for each email address across all repositories.

Disable it if you want commit-level evidence for repeated appearances of the same contributor email.

### GitHub token

A token is optional for public repositories, but recommended for larger runs.

Use a token when:

- You scan many repositories.
- You hit GitHub rate limits.
- You run organization-wide jobs.
- You need more stable throughput.

A public-repository read token is sufficient.

### Output example

```json
{
  "repository": "apify/crawlee",
  "owner": "apify",
  "repo": "crawlee",
  "commitSha": "abc123",
  "commitUrl": "https://github.com/apify/crawlee/commit/abc123",
  "authorName": "Example Developer",
  "authorEmail": "dev@example.com",
  "isNoreplyEmail": false,
  "githubLogin": "exampledev",
  "profileUrl": "https://github.com/exampledev",
  "committedAt": "2026-01-01T12:00:00Z",
  "messageSnippet": "Fix crawler retry handling",
  "sourceType": "repository",
  "scrapedAt": "2026-07-04T00:00:00Z"
}
```

### How to run

1. Add one or more repository URLs.
2. Choose a maximum number of commits per repository.
3. Decide whether to include noreply emails.
4. Run the actor.
5. Export the dataset as CSV, JSON, Excel, or via API.

### Tips for best results

- Start with `maxCommitsPerRepo` between 25 and 100.
- Use `since` for recent contributor discovery.
- Enable `dedupeByEmail` for lead lists.
- Disable dedupe for audit trails.
- Add a GitHub token for organization scans.
- Expect some commits to have noreply emails.

### Integrations

Use the output dataset in:

- CRM enrichment workflows.
- Recruiting spreadsheets.
- Developer relations lead queues.
- Open-source ecosystem dashboards.
- Vendor intelligence reports.
- Apify webhooks and integrations.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/github-contributor-email-scraper').call({
  repositories: ['apify/crawlee'],
  maxCommitsPerRepo: 50,
  includeNoreplyEmails: false,
  dedupeByEmail: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/github-contributor-email-scraper').call(run_input={
    'repositories': ['apify/crawlee'],
    'maxCommitsPerRepo': 50,
    'includeNoreplyEmails': False,
    'dedupeByEmail': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~github-contributor-email-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"repositories":["apify/crawlee"],"maxCommitsPerRepo":50}'
```

### MCP usage

Connect this actor to Apify MCP Server when you want an AI assistant to run GitHub contributor research.

MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/github-contributor-email-scraper
```

Claude Code setup:

```bash
claude mcp add apify-github-contributor-email --url "https://mcp.apify.com/?tools=fetch_cat/github-contributor-email-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-github-contributor-email": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/github-contributor-email-scraper"
    }
  }
}
```

Example prompts:

- “Find public contributor emails from apify/crawlee and return deduplicated rows.”
- “Scan recent commits from this repository and summarize contributor domains.”
- “Run a small test with noreply emails excluded.”

### Data quality notes

The actor returns public commit author emails. It does not infer private emails, bypass privacy settings, or enrich users from unrelated sources.

Some rows may contain GitHub noreply addresses, depending on the input setting and contributor privacy preferences.

GitHub login and profile URL are available when GitHub can map the commit author to a GitHub account.

### Legality and ethical use

This actor is intended for public data workflows. Use the results responsibly and comply with applicable privacy, anti-spam, employment, and data protection rules.

Do not use exported emails for unsolicited bulk messaging. Keep a legitimate business purpose and honor opt-out requests where applicable.

### FAQ

#### Is this actor collecting private GitHub emails?

No. It returns public commit author email values available in public GitHub commit metadata.

#### Can I export results to CSV?

Yes. Use the Apify dataset export menu or API to download CSV, JSON, Excel, and other formats.

### Troubleshooting

#### Why did I get zero rows?

The repository may only contain noreply emails, your date range may be too narrow, or your commit limit may be too low. Try enabling `includeNoreplyEmails` or increasing `maxCommitsPerRepo`.

#### Why did the run hit a GitHub API limit?

Unauthenticated GitHub API requests have lower rate limits. Add `githubToken` for larger scans.

#### Why is `githubLogin` empty?

Not every commit author email is mapped to a GitHub account. The email and commit URL are still saved when public.

### Related scrapers

You may also use other Apify actors by the same publisher for GitHub and developer workflow data when available:

- GitHub Profile Scraper
- GitHub Trending Scraper
- GitHub Repository Search Scraper

#### 0.1

Initial version with repository URLs, `owner/repo` inputs, organization support, date filters, noreply filtering, email dedupe, and optional GitHub token support.

### Support

If you find a repository that should return public commit emails but does not, open an issue with the input you used and a short description of the expected output.

# Actor input Schema

## `repositoryUrls` (type: `array`):

Public GitHub repository URLs to scan, for example https://github.com/apify/crawlee.

## `repositories` (type: `array`):

Optional owner/repo values. Use this when you already have repository names instead of URLs.

## `organization` (type: `string`):

Optional GitHub organization login. The actor will scan public repositories from this organization in addition to explicit repositories.

## `maxCommitsPerRepo` (type: `integer`):

How many recent commits to inspect in each repository. Keep low for quick tests, increase for deeper contributor coverage.

## `since` (type: `string`):

Optional ISO date/time. Only commits after this date are inspected.

## `until` (type: `string`):

Optional ISO date/time. Only commits before this date are inspected.

## `includeNoreplyEmails` (type: `boolean`):

When enabled, keep GitHub noreply addresses. Disable this to focus on public non-noreply commit emails.

## `dedupeByEmail` (type: `boolean`):

Save only the first row for each email address across all repositories.

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

Optional GitHub personal access token for higher API rate limits. Public repository read access is enough.

## Actor input object example

```json
{
  "repositoryUrls": [
    {
      "url": "https://github.com/apify/crawlee"
    }
  ],
  "repositories": [
    "apify/crawlee"
  ],
  "maxCommitsPerRepo": 20,
  "includeNoreplyEmails": false,
  "dedupeByEmail": true
}
```

# Actor output Schema

## `overview` (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 = {
    "repositoryUrls": [
        {
            "url": "https://github.com/apify/crawlee"
        }
    ],
    "repositories": [
        "apify/crawlee"
    ],
    "organization": "",
    "since": "",
    "until": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/github-contributor-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 = {
    "repositoryUrls": [{ "url": "https://github.com/apify/crawlee" }],
    "repositories": ["apify/crawlee"],
    "organization": "",
    "since": "",
    "until": "",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/github-contributor-email-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 '{
  "repositoryUrls": [
    {
      "url": "https://github.com/apify/crawlee"
    }
  ],
  "repositories": [
    "apify/crawlee"
  ],
  "organization": "",
  "since": "",
  "until": ""
}' |
apify call fetch_cat/github-contributor-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Contributor Email Scraper",
        "description": "Extract public GitHub contributor commit emails, names, logins, commit URLs, dates, and repository context from repos or organizations.",
        "version": "0.1",
        "x-build-id": "T7hqcqtzk9JERhHlJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~github-contributor-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-github-contributor-email-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/fetch_cat~github-contributor-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-github-contributor-email-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/fetch_cat~github-contributor-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-github-contributor-email-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": {
                    "repositoryUrls": {
                        "title": "Repository URLs",
                        "type": "array",
                        "description": "Public GitHub repository URLs to scan, for example https://github.com/apify/crawlee.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "repositories": {
                        "title": "Repository names",
                        "type": "array",
                        "description": "Optional owner/repo values. Use this when you already have repository names instead of URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organization": {
                        "title": "Organization login",
                        "type": "string",
                        "description": "Optional GitHub organization login. The actor will scan public repositories from this organization in addition to explicit repositories."
                    },
                    "maxCommitsPerRepo": {
                        "title": "Maximum commits per repository",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many recent commits to inspect in each repository. Keep low for quick tests, increase for deeper contributor coverage.",
                        "default": 20
                    },
                    "since": {
                        "title": "Since date",
                        "type": "string",
                        "description": "Optional ISO date/time. Only commits after this date are inspected."
                    },
                    "until": {
                        "title": "Until date",
                        "type": "string",
                        "description": "Optional ISO date/time. Only commits before this date are inspected."
                    },
                    "includeNoreplyEmails": {
                        "title": "Include GitHub noreply emails",
                        "type": "boolean",
                        "description": "When enabled, keep GitHub noreply addresses. Disable this to focus on public non-noreply commit emails.",
                        "default": false
                    },
                    "dedupeByEmail": {
                        "title": "Dedupe by email",
                        "type": "boolean",
                        "description": "Save only the first row for each email address across all repositories.",
                        "default": true
                    },
                    "githubToken": {
                        "title": "GitHub token",
                        "type": "string",
                        "description": "Optional GitHub personal access token for higher API rate limits. Public repository read access is enough."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```