# GitHub Scraper: Track Issues and Pull Requests by Keyword (`scrapemint/github-issue-monitor`) Actor

Track GitHub issues and pull requests by keyword, repo, label, state, and star floor. Uses the official GitHub REST API v3. Deduped across runs. Built for devtool founders, DevRel, open source maintainers, and PMs who need a live feed of category mentions, bug reports, and competitor issue activity.

- **URL**: https://apify.com/scrapemint/github-issue-monitor.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Scraper: Track Issues and Pull Requests by Keyword

Scrape GitHub for new issues and pull requests that match your keywords, repos, labels, state, and star floor. Export title, body, author, labels, reactions, repo metadata, and timestamps to JSON, CSV, or Excel. Deduped across runs. Uses the official GitHub REST API. Pay per item.

**Searches this actor is built for:** GitHub scraper, scrape GitHub issues, GitHub issue tracker, GitHub PR monitor, GitHub API alternative, GitHub keyword alert, track GitHub issues, competitor GitHub monitor, GitHub lead generation.

---

### How it works in 30 seconds

```mermaid
flowchart LR
    A[Your keywords<br/>or repo list] --> B[GitHub REST API]
    B --> C[Filter: keyword,<br/>state, label, stars, age]
    C --> D[Deduped JSON feed<br/>of new items only]
    D --> E[Webhook to Slack,<br/>CRM, Notion]
````

Paste a keyword or a `owner/repo` slug. Pick filters. Get a clean JSON feed of new GitHub issues and pull requests every run. That is the whole product.

***

### Who this GitHub scraper is for

| You are a... | You use this to... |
|---|---|
| **Devtool founder** | Catch every issue in your category mentioning your library or a competitor. Turn it into warm outbound. |
| **DevRel engineer** | Build a live queue of mentions ready for a helpful reply or bug fix. |
| **Open source maintainer** | Watch downstream repos for bug reports filed against a library you publish. |
| **Product manager** | Mine real user language from issue bodies to inform your next sprint. |
| **Competitive intel** | Track every issue filed in a competitor's repo, spot pain before their changelog does. |

***

### How to scrape GitHub issues step by step

```mermaid
flowchart TD
    A[1. Pick queries or repos] --> B[2. GitHub REST API v3]
    B --> C[3. Paginate 100 per page]
    C --> D[4. Filter by keyword,<br/>state, label, stars, age]
    D --> E[5. Push to Apify dataset]
    E --> F[6. Store ID in<br/>SEEN_IDS key value store]
    F -.->|Next run| G[7. Skip seen IDs]
```

1. Pass search queries, `owner/repo` slugs, or both.
2. The actor calls the official GitHub REST API v3: `/search/issues` for keyword search, `/repos/{owner}/{repo}/issues` for direct repo watching.
3. Results pass through keyword, state, label, star, and age filters.
4. Matches land in your Apify dataset.
5. Item IDs go into a named key value store so future runs skip duplicates.

Schedule every 10 minutes on Apify Scheduler and you get a live stream of new issues. Add a free personal access token and your rate limit jumps from 60 to 5000 core requests per hour.

***

### Quick start

**Monitor mentions of your library across all of GitHub:**

```json
{
  "searchQueries": ["\"langchain\" in:title,body"],
  "itemType": "issues",
  "state": "open",
  "maxAgeHours": 168,
  "githubToken": "YOUR_GITHUB_TOKEN"
}
```

**Watch 3 competitor repos for new bugs:**

```json
{
  "repos": ["pinecone-io/pinecone-python-client", "weaviate/weaviate", "qdrant/qdrant"],
  "keywords": ["slow", "timeout", "crash"],
  "state": "open",
  "labels": ["bug"]
}
```

**Lead gen on Postgres pain, high signal repos only:**

```json
{
  "searchQueries": ["postgres slow query in:title,body"],
  "minRepoStars": 100,
  "state": "open",
  "maxAgeHours": 72
}
```

Or run it from the command line:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~github-issue-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["langchain vector"],"state":"open","maxAgeHours":168}'
```

***

### GitHub scraper vs the alternatives

```mermaid
flowchart LR
    M[Manual repo checking] --> X[Browse each repo,<br/>miss the first wave]
    S[GitHub alert SaaS] --> Y[$20 to $99 per month,<br/>email only]
    A[This Apify actor] --> Z[Pay per item,<br/>raw JSON, your webhook]
```

| Feature | Manual | Alert SaaS | This actor |
|---|---|---|---|
| Pricing | Free, costs time | $20 to $99 per month | Pay per item, first 50 free |
| Keyword cap | Unlimited if you click | 5 to 50 per tier | Unlimited |
| Repo targeting | Tab hopping | Fixed repo list | Any repo or global search |
| Label filter | Click on GitHub | Premium tier | Built in |
| Reactions data | Hover on GitHub | Not included | Full count per emoji |
| Scheduling | You | Hourly | Every 1 minute |
| Dedup across runs | Your memory | Vendor owned | Yours, in key value store |
| Output | Browser tab | Email | JSON, CSV, Excel, webhook |

***

### Sample output

One issue record:

```json
{
  "issueId": "2387491023",
  "number": 1842,
  "itemType": "issue",
  "title": "Vector search returns empty result for multi lingual input",
  "body": "I'm trying to build a RAG pipeline with LangChain and Pinecone...",
  "state": "open",
  "url": "https://github.com/langchain-ai/langchain/issues/1842",
  "repo": {
    "slug": "langchain-ai/langchain",
    "owner": "langchain-ai",
    "name": "langchain",
    "stars": 98421,
    "language": "Python"
  },
  "author": {
    "login": "devfounder99",
    "url": "https://github.com/devfounder99"
  },
  "labels": [
    { "name": "bug", "color": "d73a4a" },
    { "name": "area: vectorstores", "color": "0075ca" }
  ],
  "commentsCount": 7,
  "reactions": { "total": 12, "plusOne": 8, "heart": 2, "rocket": 1 },
  "createdAt": "2026-04-18T11:14:00Z",
  "updatedAt": "2026-04-19T09:02:00Z",
  "matchedKeywords": ["vector"],
  "sourceKind": "search",
  "sourceValue": "langchain vector"
}
```

Every field is ready to drop into a CRM, a Slack channel, or a Notion database.

***

### Pricing

First 50 items per run are free. After that you pay per extracted item. No seats. No tier gating. A 500 item run lands under $1 on the Apify free plan.

***

### FAQ

**How do I scrape GitHub issues without an API key?**
Run the actor with no token. GitHub caps anonymous requests at 60 core and 10 search per minute. Fine for small keyword batches or one repo. For a scheduled fleet, generate a free token at `github.com/settings/tokens` and paste it into `githubToken`. Your cap jumps to 5000 core and 30 search per minute. Public data only, no scopes needed.

**Can I monitor pull requests too?**
Yes. Set `itemType` to `prs` for pull requests only, `issues` for issues only, or `all` for both. GitHub returns both from the same endpoint because a pull request is technically an issue with a `pull_request` field attached.

**How do I track one keyword across all of GitHub?**
Use `searchQueries` with GitHub's search syntax. Examples: `"vector database" in:title,body`, `stars:>100 language:python label:bug`, `org:openai type:issue`. The actor passes your query straight to `/search/issues`.

**How do I filter out low star repos?**
Set `minRepoStars`. The actor fetches repo metadata once per repo, caches it, and drops issues from repos under the floor. Useful when you only want signal from production grade users.

**Does it support private repos?**
Yes, if the token you provide has `repo` scope and access. By default the actor uses public data only.

**Does it dedupe across runs?**
Yes. Issue IDs are stored under `SEEN_IDS` in a named key value store. Every run skips seen IDs. Set `dedupe: false` to disable.

**Can I schedule it?**
Yes. Apify Scheduler goes down to 1 minute. Pair with a webhook to push new issues to Slack, Discord, Notion, or your CRM.

**What about GitHub Discussions?**
Discussions are GraphQL only on GitHub's API. This actor covers issues and pull requests via REST for speed. A separate discussions actor is on the roadmap.

**Is scraping GitHub allowed?**
Yes. This actor uses the official GitHub REST API v3, which is rate limited and public by design. No HTML scraping.

***

### Related Scrapemint actors

- **Stack Overflow Lead Monitor** for dev question tracking by tag
- **Hacker News Scraper** for stories and comments by keyword
- **Reddit Lead Monitor** for subreddit and brand mention tracking
- **Product Hunt Launch Tracker** for competitor launch monitoring
- **Upwork Opportunity Alert** for freelance lead generation
- **Trustpilot Brand Reputation** for DTC and ecommerce brands
- **Google Reviews Intelligence** for local businesses
- **Amazon Review Intelligence** for product review mining

Stack these to cover every public developer and customer conversation surface one brand touches.

# Actor input Schema

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

Free text queries passed to GitHub's /search/issues endpoint. Supports GitHub search syntax like 'langchain in:title,body', 'stars:>100 language:python label:bug', 'org:openai type:issue'. Leave empty if only watching specific repos below.

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

Specific GitHub repos to pull issues from, in the format owner/name. Example: pinecone-io/pinecone-python-client, weaviate/weaviate. Leave empty if only using search queries above.

## `keywords` (type: `array`):

Only items whose title or body contains any of these keywords are kept. Case insensitive. Leave empty to keep everything the search or repo poll returned.

## `itemType` (type: `string`):

Filter by item kind. Issues only excludes pull requests. PRs only returns pull requests. All returns both.

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

Filter by state. Open is the default. Closed returns closed items. All returns both.

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

Only keep items tagged with these labels. Example: bug, help wanted, good first issue. Multiple labels are ANDed together.

## `minRepoStars` (type: `integer`):

Drop issues from repos with fewer than this many stars. Useful when you only want signal from production grade users. Set to 0 to keep everything.

## `maxAgeHours` (type: `integer`):

Skip items created more than this many hours ago. 0 keeps everything regardless of age.

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

Created returns newest first by creation date. Updated returns items most recently updated first.

## `maxItemsPerSource` (type: `integer`):

Per source cap. GitHub pages contain up to 100 items per page and the search endpoint caps at 1000 total results.

## `maxItemsTotal` (type: `integer`):

Hard cap on items pushed to the dataset per run. Controls cost.

## `dedupe` (type: `boolean`):

Skip issue IDs pushed on previous runs. Stored in the key value store under SEEN\_IDS. Turn off to return every match on every run.

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

Raises the GitHub API rate limit from 60 core / 10 search per minute (anonymous) to 5000 core / 30 search per minute (authenticated). Generate a free token at github.com/settings/tokens. No scopes required for public data. For private repos, the token needs the repo scope.

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

Apify proxy settings. The GitHub REST API is public and rate limited, not IP limited, so a proxy is rarely needed. Add one if your schedule triggers secondary rate limits.

## Actor input object example

```json
{
  "searchQueries": [
    "\"langchain\" in:title,body"
  ],
  "repos": [],
  "itemType": "all",
  "state": "open",
  "labels": [],
  "minRepoStars": 0,
  "maxAgeHours": 168,
  "sortBy": "created",
  "maxItemsPerSource": 50,
  "maxItemsTotal": 200,
  "dedupe": true
}
```

# 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 = {
    "searchQueries": [
        "\"langchain\" in:title,body"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/github-issue-monitor").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 = { "searchQueries": ["\"langchain\" in:title,body"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/github-issue-monitor").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 '{
  "searchQueries": [
    "\\"langchain\\" in:title,body"
  ]
}' |
apify call scrapemint/github-issue-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Scraper: Track Issues and Pull Requests by Keyword",
        "description": "Track GitHub issues and pull requests by keyword, repo, label, state, and star floor. Uses the official GitHub REST API v3. Deduped across runs. Built for devtool founders, DevRel, open source maintainers, and PMs who need a live feed of category mentions, bug reports, and competitor issue activity.",
        "version": "0.1",
        "x-build-id": "ldfu0fP9PgNWW3QGJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~github-issue-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-github-issue-monitor",
                "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/scrapemint~github-issue-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-github-issue-monitor",
                "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/scrapemint~github-issue-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-github-issue-monitor",
                "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": {
                    "searchQueries": {
                        "title": "Search queries (GitHub search syntax)",
                        "type": "array",
                        "description": "Free text queries passed to GitHub's /search/issues endpoint. Supports GitHub search syntax like 'langchain in:title,body', 'stars:>100 language:python label:bug', 'org:openai type:issue'. Leave empty if only watching specific repos below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "repos": {
                        "title": "Repos to watch (owner/name)",
                        "type": "array",
                        "description": "Specific GitHub repos to pull issues from, in the format owner/name. Example: pinecone-io/pinecone-python-client, weaviate/weaviate. Leave empty if only using search queries above.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords (client side filter)",
                        "type": "array",
                        "description": "Only items whose title or body contains any of these keywords are kept. Case insensitive. Leave empty to keep everything the search or repo poll returned.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemType": {
                        "title": "Item type",
                        "enum": [
                            "all",
                            "issues",
                            "prs"
                        ],
                        "type": "string",
                        "description": "Filter by item kind. Issues only excludes pull requests. PRs only returns pull requests. All returns both.",
                        "default": "all"
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "open",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by state. Open is the default. Closed returns closed items. All returns both.",
                        "default": "open"
                    },
                    "labels": {
                        "title": "Labels filter",
                        "type": "array",
                        "description": "Only keep items tagged with these labels. Example: bug, help wanted, good first issue. Multiple labels are ANDed together.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRepoStars": {
                        "title": "Minimum repo stars",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop issues from repos with fewer than this many stars. Useful when you only want signal from production grade users. Set to 0 to keep everything.",
                        "default": 0
                    },
                    "maxAgeHours": {
                        "title": "Max age in hours",
                        "minimum": 0,
                        "maximum": 17520,
                        "type": "integer",
                        "description": "Skip items created more than this many hours ago. 0 keeps everything regardless of age.",
                        "default": 168
                    },
                    "sortBy": {
                        "title": "Sort",
                        "enum": [
                            "created",
                            "updated"
                        ],
                        "type": "string",
                        "description": "Created returns newest first by creation date. Updated returns items most recently updated first.",
                        "default": "created"
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per query or repo",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Per source cap. GitHub pages contain up to 100 items per page and the search endpoint caps at 1000 total results.",
                        "default": 50
                    },
                    "maxItemsTotal": {
                        "title": "Maximum items per run",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on items pushed to the dataset per run. Controls cost.",
                        "default": 200
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip issue IDs pushed on previous runs. Stored in the key value store under SEEN_IDS. Turn off to return every match on every run.",
                        "default": true
                    },
                    "githubToken": {
                        "title": "GitHub personal access token (optional)",
                        "type": "string",
                        "description": "Raises the GitHub API rate limit from 60 core / 10 search per minute (anonymous) to 5000 core / 30 search per minute (authenticated). Generate a free token at github.com/settings/tokens. No scopes required for public data. For private repos, the token needs the repo scope."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. The GitHub REST API is public and rate limited, not IP limited, so a proxy is rarely needed. Add one if your schedule triggers secondary rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```