# F6S Scraper - Accelerators, Startups & Investors (`jungle_synthesizer/f6s-accelerator-scraper`) Actor

Scrape F6S.com to extract accelerators, incubators, competitions, grants, startups, and investors. Get program details, startup profiles, and investor data with filters for country, stage, and sector. Ideal for founders finding accelerators, VCs seeking deal flow, and corporate innovation teams.

- **URL**: https://apify.com/jungle\_synthesizer/f6s-accelerator-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

## F6S Accelerator, Startup & Investor Scraper

Scrapes [F6S.com](https://www.f6s.com), the largest global directory of startup accelerators, competitions, grants, startups, and investors. Returns program details, startup profiles, and investor data — with filters for country, stage, and sector — from a database of 14,000+ active programs.

---

### F6S Scraper Features

- Extracts programs (accelerators, incubators, competitions, grants), startups, and investors in a single actor
- Filters by country, startup stage, industry sector, program type, and active deadline
- Returns investment amount, equity terms, application deadline, and apply URL for each program
- Captures location data (city and country) from listing cards directly
- Handles Reese84 bot protection automatically — residential proxy included
- Paginates through all results, or stops at your configured `maxItems` limit

---

### Who Uses F6S Data?

- **Founders** — Find accelerators, competitions, and grants that match your stage, sector, and geography before deadlines close
- **VCs and investors** — Identify active deal-flow sources and track which accelerators are funding which sectors
- **Corporate innovation teams** — Monitor the accelerator landscape for partnership and pipeline opportunities
- **Researchers and analysts** — Map the global startup support ecosystem, track program volumes by country and type
- **Startup support organizations** — Build databases of competing or complementary programs for strategic benchmarking

---

### How F6S Scraper Works

1. Configure the entity type (programs, startups, or investors) and any filters — country, stage, sector, deadline status
2. The scraper navigates F6S listing pages using a real browser, bypassing the bot challenge automatically with a US residential proxy
3. Listing cards are extracted from the rendered HTML — name, slug, location, investment terms, deadline, and apply URL are captured from the listing view
4. Results are returned as clean JSON; pagination continues until you hit your `maxItems` limit or the last page

---

### Input

```json
{
  "entityType": "programs",
  "country": "United States",
  "stage": "Seed",
  "sector": "FinTech",
  "programType": "accelerator",
  "deadlineOnly": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `entityType` | String | `programs` | What to scrape: `programs` (accelerators/competitions/grants), `startups`, or `investors` |
| `programType` | String | *(all)* | For programs: filter by `accelerator`, `incubator`, `competition`, `grant`, `fellowship`, `hackathon`, `studio` |
| `country` | String | *(all)* | Filter by country (e.g. `United States`, `Germany`, `Singapore`) |
| `stage` | String | *(all)* | Filter by startup stage: `Pre-Seed`, `Seed`, `Series A`, `Series B`, `Series C`, `Growth` |
| `sector` | String | *(all)* | Industry keyword filter (e.g. `FinTech`, `HealthTech`, `AI`, `ClimateTech`) |
| `deadlineOnly` | Boolean | `false` | Programs only: include only entries with upcoming application deadlines |
| `maxItems` | Integer | `10` | Max records to return. Set to `0` for unlimited |
| `proxyConfiguration` | Object | US Residential | Proxy settings — residential US recommended for bot challenge bypass |

#### Additional Input Examples

**Scrape startups in Germany:**

```json
{
  "entityType": "startups",
  "country": "Germany",
  "maxItems": 100
}
```

**Scrape investors — no filter:**

```json
{
  "entityType": "investors",
  "maxItems": 200
}
```

***

### F6S Scraper Output Fields

Each run returns one record type, determined by `entityType`. All fields are present in every record — unused entity fields are `null`.

#### Programs Output

```json
{
  "entity_type": "program",
  "program_name": "BFSI Revenue Scaler Innovation Pitches",
  "program_slug": "bfsi-revenue-scaler-innovation-pitches",
  "program_url": "https://www.f6s.com/bfsi-revenue-scaler-innovation-pitches/about",
  "program_type": "",
  "program_description": "Funds Startups in Banking, Cyber Security, Insurance",
  "program_country": "Singapore",
  "program_city": "Singapore",
  "program_stage": "",
  "program_sector": "",
  "program_benefits": "",
  "program_investment_amount": "$500k",
  "program_equity_taken": "1-10%",
  "program_duration": "",
  "program_application_deadline": "by May 10",
  "program_application_url": "https://www.f6s.com/bfsi-revenue-scaler-innovation-pitches/apply",
  "program_website": "",
  "program_companies_supported": null,
  "startup_name": null,
  "investor_name": null,
  "scraped_at": "2026-05-09T22:26:44.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `entity_type` | String | Record type: `program`, `startup`, or `investor` |
| `program_name` | String | Program name |
| `program_slug` | String | URL slug (unique identifier) |
| `program_url` | String | Full F6S program page URL |
| `program_type` | String | Program type when listed |
| `program_description` | String | Sector or focus description from listing |
| `program_country` | String | Country of operation |
| `program_city` | String | City of operation |
| `program_investment_amount` | String | Investment amount (e.g. `$500k`, `€100k`) |
| `program_equity_taken` | String | Equity percentage (e.g. `1-10%`) |
| `program_application_deadline` | String | Deadline text (e.g. `by May 10`) |
| `program_application_url` | String | Direct application URL |
| `scraped_at` | String | ISO timestamp when scraped |

#### Startups Output

```json
{
  "entity_type": "startup",
  "startup_name": "Solaris AI",
  "startup_slug": "solaris-ai",
  "startup_url": "https://www.f6s.com/solaris-ai/about",
  "startup_description": "AI-powered solar energy optimization platform",
  "startup_country": "United States",
  "startup_city": "San Francisco",
  "startup_stage": "Seed",
  "startup_founded_year": null,
  "startup_employees": "",
  "startup_website": "",
  "startup_industries": "",
  "startup_funding_raised": "",
  "program_name": null,
  "investor_name": null,
  "scraped_at": "2026-05-09T22:26:44.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `startup_name` | String | Company name |
| `startup_slug` | String | URL slug |
| `startup_url` | String | F6S company page URL |
| `startup_description` | String | Company description |
| `startup_country` | String | Country |
| `startup_city` | String | City |
| `startup_stage` | String | Funding stage |

#### Investors Output

```json
{
  "entity_type": "investor",
  "investor_name": "Sequoia Capital",
  "investor_slug": "sequoia-capital",
  "investor_url": "https://www.f6s.com/sequoia-capital/about",
  "investor_type": "Venture Capital",
  "investor_country": "United States",
  "investor_portfolio_count": null,
  "investor_investment_stage": "",
  "investor_investment_sector": "Deep Tech, AI, Consumer",
  "investor_check_size": "",
  "program_name": null,
  "startup_name": null,
  "scraped_at": "2026-05-09T22:26:44.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `investor_name` | String | Investor or fund name |
| `investor_slug` | String | URL slug |
| `investor_url` | String | F6S investor page URL |
| `investor_type` | String | Fund type |
| `investor_country` | String | Country |
| `investor_investment_sector` | String | Sector focus from listing |

***

### 🔍 FAQ

#### How do I scrape accelerators from F6S?

F6S Scraper handles it with a browser-based scrape of F6S's listing pages. Set `entityType` to `programs`, optionally add filters for country, sector, or stage, and set a `maxItems` limit. The actor handles bot protection and pagination.

#### How much does F6S Scraper cost to run?

F6S Scraper uses the `default_2603_basic` pricing profile — $0.10 per actor start plus $0.001 per record. Scraping 1,000 accelerator listings costs roughly $1.10.

#### Can I filter by deadline?

Yes. Set `deadlineOnly: true` to return only programs with upcoming application deadlines. This filter applies to programs only — not startups or investors.

#### Does F6S Scraper need proxies?

F6S Scraper requires a residential proxy to bypass the bot challenge. The default input uses Apify's residential US proxy pool. Datacenter IPs get blocked at the gate.

#### How many records are available on F6S?

F6S lists over 14,000 active programs as of early 2026. The count shifts as programs open and close. Set `maxItems: 0` to pull everything in a single run.

***

### Need More Features?

Need custom fields, additional filter options, or a different entity type? [File an issue](https://console.apify.com/actors/s7iE09haZeFU4HnjY/issues) or get in touch.

### Why Use F6S Scraper?

- **14,000+ programs covered** — F6S is the largest global accelerator directory, and this scraper reaches all of it in a single run
- **Three entity types, one actor** — programs, startups, and investors from the same database, switched with one input field rather than three separate tools
- **Filtered results at the source** — country, stage, sector, and deadline filters are applied server-side, so you only download what you need

# Actor input Schema

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

Please describe how you plan to use the data extracted by this crawler.

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

Provide any feedback or suggestions for improvements.

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

Provide your email address so we can get in touch with you.

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

Programs (accelerators/competitions/grants), startups, or investors.

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

Filter programs by type. Leave blank for all types.

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

Filter by country (e.g. 'United States', 'Germany'). Leave blank for all countries.

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

Filter by startup or investment stage.

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

Industry keyword filter (e.g. 'FinTech', 'HealthTech', 'AI', 'ClimateTech').

## `deadlineOnly` (type: `boolean`):

For programs: include only those with upcoming application deadlines.

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

Maximum number of records to return. Set to 0 for unlimited.

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

No description

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "entityType": "programs",
  "programType": "",
  "country": "",
  "stage": "",
  "sector": "",
  "deadlineOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "entityType": "programs",
    "programType": "",
    "country": "",
    "stage": "",
    "sector": "",
    "deadlineOnly": false,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/f6s-accelerator-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "entityType": "programs",
    "programType": "",
    "country": "",
    "stage": "",
    "sector": "",
    "deadlineOnly": False,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/f6s-accelerator-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "entityType": "programs",
  "programType": "",
  "country": "",
  "stage": "",
  "sector": "",
  "deadlineOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call jungle_synthesizer/f6s-accelerator-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "F6S Scraper - Accelerators, Startups & Investors",
        "description": "Scrape F6S.com to extract accelerators, incubators, competitions, grants, startups, and investors. Get program details, startup profiles, and investor data with filters for country, stage, and sector. Ideal for founders finding accelerators, VCs seeking deal flow, and corporate innovation teams.",
        "version": "0.1",
        "x-build-id": "L9e0QzLqyaohxjymB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~f6s-accelerator-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-f6s-accelerator-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/jungle_synthesizer~f6s-accelerator-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-f6s-accelerator-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/jungle_synthesizer~f6s-accelerator-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-f6s-accelerator-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",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "entityType": {
                        "title": "Entity Type",
                        "enum": [
                            "programs",
                            "startups",
                            "investors"
                        ],
                        "type": "string",
                        "description": "Programs (accelerators/competitions/grants), startups, or investors.",
                        "default": "programs"
                    },
                    "programType": {
                        "title": "Program Type",
                        "enum": [
                            "",
                            "accelerator",
                            "incubator",
                            "competition",
                            "grant",
                            "fellowship",
                            "hackathon",
                            "studio"
                        ],
                        "type": "string",
                        "description": "Filter programs by type. Leave blank for all types.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Filter by country (e.g. 'United States', 'Germany'). Leave blank for all countries.",
                        "default": ""
                    },
                    "stage": {
                        "title": "Stage",
                        "enum": [
                            "",
                            "Pre-Seed",
                            "Seed",
                            "Series A",
                            "Series B",
                            "Series C",
                            "Growth"
                        ],
                        "type": "string",
                        "description": "Filter by startup or investment stage.",
                        "default": ""
                    },
                    "sector": {
                        "title": "Sector / Industry",
                        "type": "string",
                        "description": "Industry keyword filter (e.g. 'FinTech', 'HealthTech', 'AI', 'ClimateTech').",
                        "default": ""
                    },
                    "deadlineOnly": {
                        "title": "With Active Deadline Only",
                        "type": "boolean",
                        "description": "For programs: include only those with upcoming application deadlines.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of records to return. Set to 0 for unlimited.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
