# Slack App Directory Scraper (`automation-lab/slack-app-directory-scraper`) Actor

Extract Slack Marketplace apps, vendor metadata, categories, pricing labels, support links, policy URLs, permissions, and security signals.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Slack App Directory Scraper

Extract public Slack Marketplace apps, categories, vendor pages, pricing signals, support links, policy URLs, permissions, and security metadata from `slack.com/marketplace`.

Use this actor to monitor the Slack app ecosystem, build SaaS partner lists, enrich integration databases, or track how vendors position their Slack apps over time.

---

### What does Slack App Directory Scraper do?

Slack App Directory Scraper turns public Slack Marketplace pages into structured records.

It can start from the Marketplace home page, category pages, search URLs, or specific app detail pages.

For each app, it saves identifiers, names, descriptions, categories, pricing labels, supported languages, icon URLs, vendor URLs, support URLs, privacy links, terms links, permissions, and security signals when Slack exposes them publicly.

The actor is HTTP-first and does not require a Slack account.

### Who is it for?

This actor is built for teams that need repeatable app-store intelligence.

- 🤝 **Partnership and BD teams** can find vendors that already invest in Slack integrations.
- 📊 **Competitive intelligence teams** can monitor new or changing Slack ecosystem apps.
- 🧲 **Lead generation teams** can build prospect lists from Slack Marketplace categories.
- 🧩 **Integration marketplace operators** can compare category coverage and app positioning.
- 🔐 **RevOps and security teams** can review public permission and policy signals before outreach.

### Why use this actor?

Slack Marketplace pages contain useful vendor signals, but manually browsing categories is slow.

This actor automates that workflow and returns clean JSON rows ready for export to CSV, Excel, Google Sheets, databases, or enrichment pipelines.

It also preserves the source Slack URL and scrape timestamp so you can audit where each record came from.

### What Slack data can you extract?

The output focuses on public Marketplace data.

| Field group | Examples |
| --- | --- |
| App identity | App ID, app name, app slug, Slack Marketplace URL |
| Positioning | Short description, long description, categories, pricing label |
| Vendor links | Website URL, support URL, privacy URL, terms URL |
| App metadata | Supported languages, icon URL, directory approval flags |
| Security signals | Security contact, SSO/SAML flags, pen-test date, vulnerability program |
| Permissions | Public permission text from app detail pages |

### How much does it cost to scrape Slack app directory listings?

Slack App Directory Scraper uses pay-per-event pricing.

You pay a small `$0.005` run-start fee and a per-record fee for each saved app.

The BRONZE per-app price is `$0.000027939`, with canonical tier discounts for higher Apify plans.

For low-cost first tests, keep `maxItems` small, such as 25 or 50 apps.

### Input options

The actor accepts flexible source inputs.

- `startUrls` — Slack Marketplace home, category, search, collection, or detail URLs.
- `query` — optional Slack Marketplace search phrase.
- `maxItems` — maximum number of unique apps to save.
- `enrichDetails` — visit each app detail page for deeper metadata.
- `crawlCategories` — discover category URLs from the Marketplace home page.
- `requestDelayMs` — delay between HTTP requests.

### Example input

```json
{
  "startUrls": [
    { "url": "https://slack.com/marketplace" }
  ],
  "maxItems": 100,
  "enrichDetails": true,
  "crawlCategories": true,
  "requestDelayMs": 250
}
````

### Search input example

```json
{
  "query": "crm",
  "maxItems": 50,
  "enrichDetails": false
}
```

Use search mode when you care about a theme such as CRM, support, AI assistant, project management, sales, analytics, or security.

### Category input example

```json
{
  "startUrls": [
    { "url": "https://slack.com/marketplace/category/At0EFXUU6N-productivity" }
  ],
  "maxItems": 100,
  "enrichDetails": true
}
```

Category mode is useful for recurring category monitoring.

### App detail input example

```json
{
  "startUrls": [
    { "url": "https://slack.com/marketplace/A8VK125AS-miro" }
  ],
  "maxItems": 1,
  "enrichDetails": true
}
```

Detail URLs are useful when you already know which Slack apps you want to audit.

### Output example

```json
{
  "appId": "A8VK125AS",
  "appName": "Miro",
  "appSlug": "A8VK125AS-miro",
  "appUrl": "https://slack.com/marketplace/A8VK125AS-miro",
  "shortDescription": "Visual collaboration platform",
  "developerName": "Miro",
  "categoryNames": ["Design", "Productivity"],
  "pricingInfo": "free",
  "websiteUrl": "https://miro.com/slack-integration/",
  "supportUrl": "https://miro.com/integrations/slack/",
  "privacyUrl": "https://miro.com/legal/privacy-policy/",
  "detailEnriched": true,
  "scrapedAt": "2026-06-28T00:00:00.000Z"
}
```

### Output fields

The default dataset includes these fields.

- `appId`
- `appName`
- `appSlug`
- `appUrl`
- `shortDescription`
- `longDescription`
- `developerName`
- `developerCountry`
- `categoryNames`
- `categorySlugs`
- `pricingInfo`
- `supportedLanguages`
- `iconUrl`
- `websiteUrl`
- `supportUrl`
- `privacyUrl`
- `termsUrl`
- `permissionsCanView`
- `permissionsCanDo`
- `securityContact`
- `latestPenTestDate`
- `supportsSso`
- `supportsSaml`
- `vulnerabilityDisclosureProgram`
- `isSlackCertified`
- `isDirectoryApproved`
- `isDirectoryPublished`
- `isDistributed`
- `sourceUrl`
- `detailEnriched`
- `scrapedAt`

### Tips for best results

Start with the Marketplace home page and `crawlCategories: true` when you want broad coverage.

Use `enrichDetails: false` when you only need fast listing data.

Use `enrichDetails: true` when you need vendor URLs, policies, permission text, or security signals.

Set a moderate `requestDelayMs` for recurring monitoring jobs.

Keep `maxItems` low for quick tests, then scale once the output matches your workflow.

### Common workflows

- Build a list of Slack-integrated SaaS vendors by category.
- Track app descriptions and positioning changes over time.
- Find apps with public support and privacy URLs for partner research.
- Compare categories such as productivity, sales, HR, AI, and security.
- Enrich a CRM with Slack Marketplace app URLs and vendor websites.

### Integrations

You can connect the dataset to many downstream tools.

- Export CSV for spreadsheets.
- Send JSON to a data warehouse.
- Trigger Zapier or Make scenarios from completed runs.
- Use Apify webhooks to notify your team when a monitoring run finishes.
- Combine output with company enrichment APIs for lead scoring.

### 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/slack-app-directory-scraper').call({
  startUrls: [{ url: 'https://slack.com/marketplace' }],
  maxItems: 100,
  enrichDetails: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/slack-app-directory-scraper').call(run_input={
    'query': 'crm',
    'maxItems': 50,
    'enrichDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~slack-app-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://slack.com/marketplace"}],"maxItems":100,"enrichDetails":true}'
```

### MCP usage

Use this actor from Apify MCP tools in Claude Code or Claude Desktop.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/slack-app-directory-scraper
```

Claude Code setup:

```bash
claude mcp add apify-slack-directory "https://mcp.apify.com/?tools=automation-lab/slack-app-directory-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Run the Slack App Directory Scraper for CRM apps and summarize the top vendors."
- "Find Slack Marketplace apps in productivity and return vendor websites."
- "Monitor Slack app categories and flag new apps with privacy URLs."

### Data freshness

The actor reads the current public Slack Marketplace HTML at run time.

Slack can change app listings, categories, pricing labels, and public security fields.

For monitoring, schedule regular runs and compare new datasets against earlier exports.

### Limitations

The actor only uses public pages.

It does not authenticate to Slack.

It does not inspect private workspace installations.

Some public detail pages may not expose every security or vendor field.

Public email addresses are not guaranteed because many vendors publish support portals instead.

### Legality

This actor extracts publicly available information from public Slack Marketplace pages.

You should use the data responsibly, respect Slack's terms, avoid excessive request rates, and comply with privacy, marketing, and data protection laws that apply to your use case.

If you plan outreach, verify contact details and honor opt-out requirements.

### Troubleshooting

If you receive fewer items than expected, increase `maxItems`, enable `crawlCategories`, or provide more category URLs.

If detail fields are empty, make sure `enrichDetails` is enabled and that the specific Slack app detail page exposes those fields publicly.

If a run is slower than expected, disable detail enrichment for listing-only workflows.

### FAQ

#### Do I need a Slack account?

No. The actor works from public Slack Marketplace pages.

#### Can it scrape every app in the Marketplace?

It can crawl public category payloads exposed by Slack Marketplace pages. Coverage depends on what Slack returns in server-rendered public HTML.

#### Can I scrape one app only?

Yes. Provide one Slack app detail URL and set `maxItems` to 1.

#### Does it use a browser?

No. It uses HTTP and Cheerio for lower cost and faster runs.

### Related scrapers

Automation Lab maintains multiple marketplace and directory intelligence actors.

Explore related actors at `https://apify.com/automation-lab/`.

Good companion workflows include SaaS directory scraping, app marketplace monitoring, lead enrichment, and website contact discovery.

### Support

If you need a custom field, a specific Slack Marketplace category workflow, or an integration with your database, open an issue on the actor page.

Include your input JSON and a short example of the output you expected.

### Changelog

- Initial version: Slack Marketplace listing extraction, category discovery, search input, detail enrichment, and structured app output.

# Actor input Schema

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

Slack Marketplace home, category, collection, search, or app detail URLs. Leave empty to crawl the Marketplace home page and discovered categories.

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

Optional Slack Marketplace search phrase, such as crm, ai assistant, support, or project management.

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

Maximum number of unique Slack apps to save.

## `enrichDetails` (type: `boolean`):

Visit each app detail page to capture developer, support, privacy, permissions, and security metadata. Turn off for fast listing-only runs.

## `crawlCategories` (type: `boolean`):

When a Marketplace home URL is provided, also crawl the public category URLs listed on that page until maxItems is reached.

## `requestDelayMs` (type: `integer`):

Delay between Slack Marketplace HTTP requests. Increase if you want slower, gentler crawling.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://slack.com/marketplace"
    }
  ],
  "query": "crm",
  "maxItems": 20,
  "enrichDetails": true,
  "crawlCategories": true,
  "requestDelayMs": 250
}
```

# 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://slack.com/marketplace"
        }
    ],
    "query": "crm",
    "maxItems": 20,
    "enrichDetails": true,
    "crawlCategories": true,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/slack-app-directory-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://slack.com/marketplace" }],
    "query": "crm",
    "maxItems": 20,
    "enrichDetails": True,
    "crawlCategories": True,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/slack-app-directory-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://slack.com/marketplace"
    }
  ],
  "query": "crm",
  "maxItems": 20,
  "enrichDetails": true,
  "crawlCategories": true,
  "requestDelayMs": 250
}' |
apify call automation-lab/slack-app-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Slack App Directory Scraper",
        "description": "Extract Slack Marketplace apps, vendor metadata, categories, pricing labels, support links, policy URLs, permissions, and security signals.",
        "version": "0.1",
        "x-build-id": "cAkR9UniFpDb30aj3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~slack-app-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-slack-app-directory-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~slack-app-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-slack-app-directory-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~slack-app-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-slack-app-directory-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": "Slack Marketplace home, category, collection, search, or app detail URLs. Leave empty to crawl the Marketplace home page and discovered categories.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional Slack Marketplace search phrase, such as crm, ai assistant, support, or project management."
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique Slack apps to save.",
                        "default": 20
                    },
                    "enrichDetails": {
                        "title": "Enrich app detail pages",
                        "type": "boolean",
                        "description": "Visit each app detail page to capture developer, support, privacy, permissions, and security metadata. Turn off for fast listing-only runs.",
                        "default": true
                    },
                    "crawlCategories": {
                        "title": "Crawl discovered categories",
                        "type": "boolean",
                        "description": "When a Marketplace home URL is provided, also crawl the public category URLs listed on that page until maxItems is reached.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between Slack Marketplace HTTP requests. Increase if you want slower, gentler crawling.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```