# GitHub Marketplace Scraper (`automation-lab/github-marketplace-scraper`) Actor

Extract GitHub Marketplace apps and actions from public pages for vendor intelligence, category monitoring, and developer-tool leads.

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

## Pricing

from $0.03 / 1,000 item extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Marketplace Scraper

Extract public GitHub Marketplace apps and actions for vendor intelligence, lead generation, ecosystem research, and partner discovery.

The actor reads GitHub Marketplace browse, search, category, and detail pages without logging in. It returns names, slugs, Marketplace URLs, listing type, short descriptions, pricing/free-trial signals, badge signals, images, optional detail text, and public install/setup links.

### What does GitHub Marketplace Scraper do?

GitHub Marketplace Scraper turns GitHub Marketplace pages into a clean dataset.

It can collect marketplace listings from:

- 🔎 App browse pages
- 🔎 Action browse pages
- 🔎 Search result pages
- 🔎 Category pages
- 🔎 Individual app detail pages
- 🔎 Individual action detail pages

Use it when you need repeatable GitHub Marketplace data instead of manual copy-paste.

### Who is it for?

This scraper is useful for several buyer workflows.

- 🧩 Developer-tool companies tracking adjacent vendors
- 🤝 Partnership teams looking for integration leads
- 🛠️ DevOps agencies building vendor shortlists
- 📈 Ecosystem analysts monitoring Marketplace categories
- 🧪 Product managers researching pricing and positioning
- 🧲 Growth teams collecting GitHub app/action lead lists

### Why use this actor?

GitHub Marketplace is a high-signal directory of tools that sell to developers.

Manual browsing is slow because useful data is split across search pages, category pages, and listing detail pages.

This actor gives you structured records that are easier to filter, enrich, deduplicate, and monitor over time.

### What data can you extract?

Each dataset item represents one Marketplace listing.

| Field | Description |
| --- | --- |
| `name` | Marketplace app or action name |
| `slug` | Stable GitHub Marketplace slug |
| `marketplaceUrl` | Public listing URL |
| `listingType` | App or Action label when visible |
| `developer` | Publisher/creator signal when available |
| `description` | Short description |
| `categories` | Category signals from detail pages |
| `pricingSignals` | Free, paid, pricing, subscription, or open-source text signals |
| `freeTrial` | Free-trial signal when found |
| `badges` | Badge signals such as verified |
| `detailText` | Optional long detail text |
| `imageUrls` | Logo, screenshot, or OpenGraph image URLs |
| `installLinks` | Install, setup, pricing, or getting-started links |
| `setupLinks` | Docs, support, website, or guide links |
| `sourceUrl` | Page where the listing was discovered |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape GitHub Marketplace?

The actor uses pay-per-event pricing.

- A small start event is charged once per run: $0.005.
- A per-listing event is charged for each saved dataset item. BRONZE is $0.000051062 per listing, with lower tiers for higher-volume plans.
- Detail-page extraction costs more compute time because it opens each listing page, but it does not change the event type.

Keep `maxItems` low for first tests, then increase it when the output matches your workflow.

### Input options

You can drive the actor with URLs, searches, categories, or a mix.

#### Start URLs

Use `startUrls` when you already know the Marketplace pages to scrape.

Examples:

```json
[
  { "url": "https://github.com/marketplace?type=apps" },
  { "url": "https://github.com/marketplace?type=actions&query=security" },
  { "url": "https://github.com/marketplace/render" }
]
````

#### Search queries

Use `searchQueries` for keyword discovery.

```json
["security", "ci", "monitoring"]
```

#### Categories

Use `categories` for Marketplace category slugs.

```json
["continuous-integration", "code-quality"]
```

#### Listing type

Set `type` to either:

- `apps`
- `actions`

#### Maximum listings

`maxItems` limits the number of records saved.

#### Open detail pages

Set `includeDetails` to `true` when you need long descriptions, categories, and public setup/resource links.

### Example input: app vendor discovery

```json
{
  "searchQueries": ["security", "code review", "monitoring"],
  "type": "apps",
  "maxItems": 50,
  "includeDetails": true
}
```

### Example input: GitHub Actions research

```json
{
  "startUrls": [
    { "url": "https://github.com/marketplace?type=actions&query=deploy" },
    { "url": "https://github.com/marketplace?type=actions&query=test" }
  ],
  "maxItems": 100,
  "includeDetails": false
}
```

### Example output

```json
{
  "name": "Render",
  "slug": "render",
  "marketplaceUrl": "https://github.com/marketplace/render",
  "listingType": "App",
  "developer": null,
  "description": "Continuous integration and deploys with Render, the modern cloud for ambitious developers",
  "categories": [],
  "pricingSignals": [],
  "freeTrial": false,
  "badges": [],
  "detailText": null,
  "imageUrls": ["https://avatars.githubusercontent.com/ml/4937?s=400&v=4"],
  "installLinks": [],
  "setupLinks": [],
  "sourceUrl": "https://github.com/marketplace?type=apps",
  "scrapedAt": "2026-06-29T02:09:06.842Z"
}
```

### Tips for best results

- Start with one or two search terms.
- Use `includeDetails=false` for broad monitoring.
- Use `includeDetails=true` for lead qualification.
- Mix app and action URLs if you need both ecosystems.
- Keep searches specific: `security`, `ci`, `deploy`, `code review`, or `observability`.

### Integrations

Common workflows include:

- Export to Google Sheets for vendor review.
- Send records to a CRM as developer-tool leads.
- Store daily snapshots in a database for monitoring.
- Join Marketplace listings with GitHub organization or website enrichment.
- Feed records into competitive-intelligence dashboards.

### 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('automation-lab/github-marketplace-scraper').call({
  searchQueries: ['security'],
  type: 'apps',
  maxItems: 25,
  includeDetails: false,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/github-marketplace-scraper').call(run_input={
    'searchQueries': ['security'],
    'type': 'apps',
    'maxItems': 25,
    'includeDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~github-marketplace-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["security"],"type":"apps","maxItems":25,"includeDetails":false}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/github-marketplace-scraper
```

Claude Code setup:

```bash
claude mcp add apify-github-marketplace "https://mcp.apify.com/?tools=automation-lab/github-marketplace-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-github-marketplace": {
      "url": "https://mcp.apify.com/?tools=automation-lab/github-marketplace-scraper"
    }
  }
}
```

Example prompts:

- "Scrape GitHub Marketplace security apps and summarize pricing signals."
- "Find GitHub Actions related to deployment and return their Marketplace URLs."
- "Monitor GitHub Marketplace CI tools and highlight new vendors."

### Data quality notes

GitHub Marketplace pages are public but the visible HTML can change.

The actor is designed to parse stable page signals first: listing links, names, descriptions, type labels, badges, images, and public links.

When GitHub does not expose a field on a page, the actor returns `null` or an empty array rather than inventing data.

### Legality

This actor extracts publicly available GitHub Marketplace pages.

You are responsible for using the data in compliance with GitHub terms, privacy law, and your own obligations.

Do not use scraped data for spam, abuse, credential attacks, or unwanted outreach.

### FAQ

#### Can this scraper access private GitHub Marketplace data?

No. It only reads public pages and does not log in.

### Troubleshooting

#### Why did I get fewer results than expected?

GitHub may show a limited number of listings for a query or category. Add more specific start URLs or search queries.

#### Why are detail fields empty?

Set `includeDetails=true` to visit each listing detail page. Broad listing runs keep it off by default for speed and cost control.

#### Why are pricing signals not exact prices?

The actor extracts visible text signals such as `free`, `paid`, or `pricing`. Marketplace billing details can vary by vendor and may require clicking external vendor pages.

### Related scrapers

Related Automation Lab actors:

- https://apify.com/automation-lab/github-scraper
- https://apify.com/automation-lab/github-trending-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/software-company-scraper

### Changelog

#### 0.1

Initial private build for GitHub Marketplace app/action extraction.

### Support

If a page stops parsing correctly, open an issue with:

- The exact input JSON
- A sample Marketplace URL
- Expected fields
- A run URL if available

### Limits

The actor does not log in to GitHub.

It does not install apps or actions.

It does not scrape private repositories.

It does not claim that text signals are official vendor pricing unless GitHub visibly exposes those signals.

### Monitoring workflow

For recurring monitoring, run the actor daily or weekly with the same input and compare records by `slug` and `marketplaceUrl`.

Useful comparison fields include `description`, `pricingSignals`, `badges`, `categories`, and `scrapedAt`.

### Lead generation workflow

For lead generation, combine Marketplace data with company websites, GitHub organizations, LinkedIn research, or CRM enrichment.

Use `includeDetails=true` for smaller lead lists where setup links and detail text matter.

### Competitive intelligence workflow

For competitive intelligence, run category searches over time.

Track changes in visible positioning, badge signals, listing descriptions, and new entrants in relevant categories.

# Actor input Schema

## `startUrls` (type: `array`):

Optional GitHub Marketplace listing, search, category, or detail URLs. Leave empty to use search queries/categories or the default marketplace browse page.

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

Marketplace keywords to search, for example CI, security, code review, monitoring, or AI.

## `categories` (type: `array`):

Marketplace category slugs or names. Spaces are converted to hyphens, e.g. code review -> code-review.

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

Choose whether to scrape GitHub Marketplace Apps or Actions.

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

Maximum number of marketplace listings to save.

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

Visit each listing detail page to extract long text, public setup/install links, categories, and richer pricing/badge signals. Slower but more complete.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://github.com/marketplace?type=apps"
    }
  ],
  "searchQueries": [
    "security",
    "ci"
  ],
  "categories": [
    "code-quality",
    "continuous-integration"
  ],
  "type": "apps",
  "maxItems": 20,
  "includeDetails": false
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://github.com/marketplace?type=apps"
        }
    ],
    "searchQueries": [
        "security",
        "ci"
    ],
    "categories": [
        "code-quality",
        "continuous-integration"
    ],
    "type": "apps",
    "maxItems": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/github-marketplace-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 = {
    "startUrls": [{ "url": "https://github.com/marketplace?type=apps" }],
    "searchQueries": [
        "security",
        "ci",
    ],
    "categories": [
        "code-quality",
        "continuous-integration",
    ],
    "type": "apps",
    "maxItems": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/github-marketplace-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 '{
  "startUrls": [
    {
      "url": "https://github.com/marketplace?type=apps"
    }
  ],
  "searchQueries": [
    "security",
    "ci"
  ],
  "categories": [
    "code-quality",
    "continuous-integration"
  ],
  "type": "apps",
  "maxItems": 20,
  "includeDetails": false
}' |
apify call automation-lab/github-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Marketplace Scraper",
        "description": "Extract GitHub Marketplace apps and actions from public pages for vendor intelligence, category monitoring, and developer-tool leads.",
        "version": "0.1",
        "x-build-id": "OomUeHhuSlrx3nrPQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~github-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-github-marketplace-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/automation-lab~github-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-github-marketplace-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/automation-lab~github-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-github-marketplace-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional GitHub Marketplace listing, search, category, or detail URLs. Leave empty to use search queries/categories or the default marketplace browse page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Marketplace keywords to search, for example CI, security, code review, monitoring, or AI.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Marketplace category slugs or names. Spaces are converted to hyphens, e.g. code review -> code-review.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "type": {
                        "title": "Listing type",
                        "enum": [
                            "apps",
                            "actions"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape GitHub Marketplace Apps or Actions.",
                        "default": "apps"
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of marketplace listings to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Visit each listing detail page to extract long text, public setup/install links, categories, and richer pricing/badge signals. Slower but more complete.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```