# GitHub Issues & Pull Requests Scraper (`fetch_cat/github-issues-pull-requests-scraper`) Actor

Extract public GitHub issues and pull requests from repositories or search queries for DevRel, support, product, and AI workflows.

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

## Pricing

from $0.03 / 1,000 github issue or pull requests

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

## GitHub Issues & Pull Requests Scraper

Extract public GitHub issues and pull requests from repositories or GitHub search queries.

Use this actor to monitor open-source demand, support pain, competitor roadmaps, bug reports, feature requests, and pull request activity.

### What does GitHub Issues & Pull Requests Scraper do?

This actor turns public GitHub issue and pull request search results into a clean dataset.

It accepts repository names such as `microsoft/vscode`.

It also accepts GitHub issue search queries such as `repo:microsoft/vscode is:issue label:bug`.

The output includes issue and pull request metadata, labels, author details, timestamps, comments, reactions, and source-query provenance.

### Who is it for?

#### DevRel teams

Track what developers ask for across important open-source projects.

#### Product managers

Find repeated bugs, integration gaps, feature requests, and migration pain.

#### Support teams

Monitor public issues mentioning your product, API, SDK, or competitor.

#### Founders and growth teams

Discover high-intent leads from public problems and requests.

#### AI and data teams

Collect structured issue and pull request records for RAG, classification, or trend analysis.

### Why use this actor?

GitHub search is powerful, but manual monitoring is slow.

This actor saves repeatable searches as exportable data.

You can schedule it, connect it to integrations, or call it from code.

You get consistent fields instead of copying records by hand.

### What data can you extract?

| Field | Description |
| --- | --- |
| `repository` | Repository that owns the issue or pull request |
| `type` | `issue` or `pull_request` |
| `number` | GitHub issue or pull request number |
| `title` | Record title |
| `bodyExcerpt` | Short plain-text body excerpt |
| `state` | Open or closed state |
| `url` | Public GitHub URL |
| `apiUrl` | GitHub API URL |
| `authorLogin` | Author username |
| `authorProfileUrl` | Author profile URL |
| `labels` | Label names |
| `assignees` | Assigned usernames |
| `milestone` | Milestone title |
| `commentsCount` | Number of comments |
| `reactions` | Reaction counts |
| `createdAt` | Creation timestamp |
| `updatedAt` | Last update timestamp |
| `closedAt` | Close timestamp |
| `mergedAt` | Merge timestamp when available |
| `sourceQuery` | Query used to find the record |
| `sourceRepository` | Repository input that generated the query |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape GitHub issues and pull requests?

The actor uses pay-per-event pricing.

A small start event is charged once per run.

A per-result event is charged for each saved issue or pull request.

The BRONZE per-result price is `$0.000025262` per saved issue or pull request, with tiered discounts for higher Apify plans.

That is about `$0.0253` per 1,000 saved records before the start event.

Use a low `maxItems` value for your first test run.

### Input overview

You can use repositories, search queries, or both.

If you provide both, the actor processes all sources in one run until `maxItems` is reached.

#### Repositories

Use repository names in `owner/name` format.

Examples:

- `microsoft/vscode`
- `nodejs/node`
- `facebook/react`

Repository URLs are also accepted.

#### Search queries

Use GitHub issue search syntax.

Examples:

- `repo:microsoft/vscode is:issue label:bug`
- `kubernetes error "good first issue"`
- `org:vercel is:pr state:open`

### Example input

```json
{
  "repositories": ["microsoft/vscode"],
  "searchQueries": [],
  "state": "open",
  "includeIssues": true,
  "includePullRequests": true,
  "labels": [],
  "maxItems": 25
}
````

### Search filters

#### State

Choose `open`, `closed`, or `all`.

#### Include issues

Enable this to save GitHub issues.

#### Include pull requests

Enable this to save GitHub pull requests.

#### Labels

Add label names such as `bug`, `documentation`, or `good first issue`.

The actor appends these filters to generated repository searches.

#### Updated since

Use `since` to collect records updated after a date.

This is useful for scheduled monitoring.

### Output example

```json
{
  "repository": "microsoft/vscode",
  "type": "issue",
  "number": 123,
  "title": "Example issue title",
  "state": "open",
  "url": "https://github.com/microsoft/vscode/issues/123",
  "authorLogin": "octocat",
  "labels": ["bug"],
  "commentsCount": 4,
  "createdAt": "2026-01-01T00:00:00Z",
  "updatedAt": "2026-01-02T00:00:00Z"
}
```

### How to scrape a repository

1. Open the actor input form.
2. Add one or more repositories.
3. Choose state and issue / pull request options.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### How to monitor a keyword

1. Add a GitHub search query.
2. Include words, labels, organizations, or repositories.
3. Set `since` for incremental monitoring.
4. Schedule the actor daily or weekly.
5. Send new rows to your destination system.

### Tips for better results

💡 Use repository-specific queries for precise output.

💡 Use labels to focus on bugs, feature requests, or onboarding tasks.

💡 Use `since` for recurring jobs so each run stays small.

💡 Start with `maxItems: 25` before scaling up.

💡 Add a GitHub token only when you need higher rate limits.

### Rate limits

Public GitHub data can be fetched without a token for small runs.

GitHub applies rate limits to unauthenticated API usage.

For larger monitoring workflows, provide a GitHub token in the optional secret input.

The token is used only to request public API data with a higher rate limit.

### Integrations

Send dataset rows to Google Sheets for manual review.

Send issue records to Slack or Discord for support triage.

Load pull request data into a warehouse for engineering analytics.

Use webhooks to trigger workflows when new matching issues appear.

Feed output into LLM classification or RAG pipelines.

### API usage

#### 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-issues-pull-requests-scraper').call({
  repositories: ['microsoft/vscode'],
  state: 'open',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/github-issues-pull-requests-scraper').call(run_input={
    'repositories': ['microsoft/vscode'],
    'state': 'open',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~github-issues-pull-requests-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"repositories":["microsoft/vscode"],"state":"open","maxItems":25}'
```

### MCP usage

You can run this actor from Apify MCP tools.

Use this tool URL pattern:

`https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper`

Add it to Claude Code with:

```bash
claude mcp add apify-github-issues "https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper"
```

For a JSON MCP configuration, use:

```json
{
  "mcpServers": {
    "apify-github-issues": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=fetch_cat/github-issues-pull-requests-scraper"
      ]
    }
  }
}
```

#### Example MCP prompts

Use these prompts after connecting the actor through MCP.

Example prompt ideas:

#### Claude Code prompt

"Use the Apify GitHub Issues & Pull Requests Scraper tool for microsoft/vscode and summarize the top open bugs."

#### Claude Desktop prompt

"Use the MCP GitHub issues scraper to find recent open pull requests in nodejs/node and group them by likely topic."

#### Agent workflow prompt

"With the Apify MCP tool, monitor GitHub issues mentioning our SDK every day and send high-priority records to Slack."

### Common workflows

#### Competitive intelligence

Track public issues in competitor repositories.

Look for bug patterns, integration gaps, and roadmap signals.

#### DevRel monitoring

Find developers asking for help with your ecosystem.

Prioritize responses by comments, labels, or recency.

#### Product discovery

Collect feature requests and pain points from open-source communities.

Classify titles and body excerpts with your preferred AI model.

#### Engineering analytics

Export pull request metadata for reporting on activity and review flow.

Combine with other GitHub or CI data sources.

### Troubleshooting

#### The run says GitHub rate limit reached

Use a smaller `maxItems`, wait for the reset window, or provide a GitHub token.

#### My query returns no data

Check the query in GitHub search first, then copy the same syntax into `searchQueries`.

#### I only want issues, not pull requests

Set `includeIssues` to `true` and `includePullRequests` to `false`.

#### I only want pull requests

Set `includeIssues` to `false` and `includePullRequests` to `true`.

### Data quality notes

The actor returns public GitHub metadata available through GitHub search.

Some fields may be empty when GitHub does not provide that value.

Body text is saved as an excerpt to keep rows compact.

Use `url` to open the full public issue or pull request.

### Legality and responsible use

This actor extracts public GitHub issue and pull request data.

You are responsible for using the data in accordance with GitHub's terms, privacy expectations, and applicable laws.

Do not use the output for spam, harassment, or abusive automation.

Respect users and project maintainers.

### Related scrapers

Explore related Apify actors from `fetch_cat` for developer intelligence and open-source research.

- [GitHub Profile Scraper](https://apify.com/fetch_cat/github-profile-scraper)
- [GitHub Repository Search Scraper](https://apify.com/fetch_cat/github-repository-search-scraper)
- [GitHub Trending Scraper](https://apify.com/fetch_cat/github-trending-scraper)
- [GitHub Contributor Email Scraper](https://apify.com/fetch_cat/github-contributor-email-scraper)

Use GitHub issue data together with other public web datasets to enrich product and market research.

### FAQ

#### Does this require a GitHub account?

No for small public-data runs.

A token is optional for higher rate limits.

#### Can it access private repositories?

No. This actor is designed for public GitHub issues and pull requests.

#### Can I schedule it?

Yes. Use Apify schedules and the `since` field for recurring monitoring.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, or through the API.

#### Can I scrape comments?

The first version saves comment counts, not full comment threads.

#### Can I combine multiple repositories?

Yes. Add multiple repository names to `repositories`.

#### Can I combine repositories and search queries?

Yes. The actor processes both input sources in one run.

### Changelog

Initial version supports public repository and search-query scraping for GitHub issues and pull requests.

# Actor input Schema

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

Public GitHub repositories to search, in owner/name form or as repository URLs.

## `searchQueries` (type: `array`):

Optional raw GitHub issue search queries, for example: repo:microsoft/vscode is:issue label:bug. Repository and query inputs are combined into one run.

## `state` (type: `string`):

Issue or pull request state to include.

## `includeIssues` (type: `boolean`):

Include GitHub issues in the output.

## `includePullRequests` (type: `boolean`):

Include GitHub pull requests in the output.

## `labels` (type: `array`):

Optional GitHub label filters appended to generated searches, for example bug or good first issue.

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

Only include issues or pull requests updated on or after this date. Use YYYY-MM-DD or an ISO date string.

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

Maximum number of dataset rows to save across all repositories and search queries.

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

Optional GitHub personal access token for higher API rate limits. Public data works without a token for small runs.

## Actor input object example

```json
{
  "repositories": [
    "microsoft/vscode"
  ],
  "searchQueries": [],
  "state": "open",
  "includeIssues": true,
  "includePullRequests": true,
  "labels": [],
  "maxItems": 20
}
```

# 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 = {
    "repositories": [
        "microsoft/vscode"
    ],
    "searchQueries": [],
    "labels": [],
    "since": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/github-issues-pull-requests-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 = {
    "repositories": ["microsoft/vscode"],
    "searchQueries": [],
    "labels": [],
    "since": "",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/github-issues-pull-requests-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 '{
  "repositories": [
    "microsoft/vscode"
  ],
  "searchQueries": [],
  "labels": [],
  "since": ""
}' |
apify call fetch_cat/github-issues-pull-requests-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Issues & Pull Requests Scraper",
        "description": "Extract public GitHub issues and pull requests from repositories or search queries for DevRel, support, product, and AI workflows.",
        "version": "0.1",
        "x-build-id": "GqYEafGkmvkwTaGYK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~github-issues-pull-requests-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-github-issues-pull-requests-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-issues-pull-requests-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-github-issues-pull-requests-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-issues-pull-requests-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-github-issues-pull-requests-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": {
                    "repositories": {
                        "title": "Repositories",
                        "type": "array",
                        "description": "Public GitHub repositories to search, in owner/name form or as repository URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional raw GitHub issue search queries, for example: repo:microsoft/vscode is:issue label:bug. Repository and query inputs are combined into one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "open",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Issue or pull request state to include.",
                        "default": "open"
                    },
                    "includeIssues": {
                        "title": "Include issues",
                        "type": "boolean",
                        "description": "Include GitHub issues in the output.",
                        "default": true
                    },
                    "includePullRequests": {
                        "title": "Include pull requests",
                        "type": "boolean",
                        "description": "Include GitHub pull requests in the output.",
                        "default": true
                    },
                    "labels": {
                        "title": "Labels",
                        "type": "array",
                        "description": "Optional GitHub label filters appended to generated searches, for example bug or good first issue.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "since": {
                        "title": "Updated since",
                        "type": "string",
                        "description": "Only include issues or pull requests updated on or after this date. Use YYYY-MM-DD or an ISO date string."
                    },
                    "maxItems": {
                        "title": "Maximum issues / pull requests",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of dataset rows to save across all repositories and search queries.",
                        "default": 20
                    },
                    "githubToken": {
                        "title": "GitHub token (optional)",
                        "type": "string",
                        "description": "Optional GitHub personal access token for higher API rate limits. Public data works without a token for small runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
