# All In One Username Availability Checker (`scrapedrift/all-in-one-username-availability-checker`) Actor

🔎 All In One Username Availability Checker checks username availability across platforms instantly. ⚡ Find your perfect handle faster, avoid conflicts, and secure your brand name today. ✅ Fast, easy, and reliable! 🚀✨

- **URL**: https://apify.com/scrapedrift/all-in-one-username-availability-checker.md
- **Developed by:** [ScrapeDrift](https://apify.com/scrapedrift) (community)
- **Categories:** Automation, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### All-In-One Username Availability Checker ⚡

Getting a “is this handle taken?” answer across multiple platforms is time-consuming—especially when you need consistency for branding, campaigns, or launches. **All-In-One Username Availability Checker** checks username availability on 85+ platforms for you, so you can quickly find available handles. It’s a fast username availability checker and instant username checker built for marketers, community managers, and developers. Run it once, review the results, and move forward without manually checking each site one by one.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
[
  {
    "id": "294847563901",
    "platform": "youtube",
    "profile_url": "",
    "status": "Available"
  },
  {
    "id": "730215689407",
    "platform": "x",
    "profile_url": "https://x.com/emilywritespoem",
    "status": "Not Available"
  },
  {
    "id": "105904372816",
    "platform": "instagram",
    "profile_url": "",
    "status": "Unknown"
  }
]
````

| Field | Type | What It Tells You |
|---|---|---|
| `id` | string | A unique identifier for the record in this run (useful for deduping). |
| `platform` | string | Which platform the username was checked on (so you can pick the right handle). |
| `profile_url` | string | A profile link when the username is marked “Not Available” and a profile URL can be constructed. |
| `status` | string | The availability outcome: `Available`, `Not Available`, or `Unknown` (for `instagram` and `twitch`). |
| `keyword` | string | The username input you asked to check (from your run input). |
| `platform` | string | The platform name as returned in the result records for easy filtering. |
| `profile_url` | string | Lets you quickly verify what already uses the handle. |
| `status` | string | Lets you branch your workflow: pick available handles, or adjust naming if taken. |
| `id` | string | Helps track and audit what your run produced. |
| `profile_url` | string | Empty when no profile URL is available for that status/platform combination. |
| `status` | string | “Unknown” indicates the actor cannot determine availability for that platform in its output logic. |
| `profile_url` | string | Useful for reporting and internal review when a handle is already taken. |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keyword": "emilywritespoem",
  "platform": "All",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keyword` | ✅ | The username (handle) you want to check for availability. |
| `platform` | ⬜ | Select a platform to check (or choose `"All"` to check every platform). |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor. |
| ↳ (within) `proxyConfiguration` | ⬜ | Proxy settings are passed through to Apify proxy configuration for the run. |

***

### What It Does

All-In-One Username Availability Checker checks a username across multiple platforms and returns a merged, ready-to-export dataset with availability results.

#### Coverage across many platforms

This username availability checker is designed to check username availability on 85+ platforms. You can run it for one platform or choose `"All"` to compare handle availability across the whole set in a single run.

#### Fast results for “check username availability” workflows

Use this check username availability tool when you need quick answers for branding, campaign naming, or community growth. Instead of manually searching platform-by-platform, you get a consolidated dataset you can act on immediately.

#### Instant username checker output you can filter

Results are returned as records with `platform`, `profile_url`, and `status`. That makes it easy to separate “Available” handles from “Not Available” ones during analysis or outreach planning.

#### Built-in proxy support for reliable scraping

The actor supports proxy configuration via `proxyConfiguration` so you can improve reliability for bulk runs. This helps when platforms behave inconsistently or restrict repeated access.

#### Handles unknown cases explicitly

For `instagram` and `twitch`, the output `status` is set to `Unknown`. This keeps your downstream pipeline honest—so you don’t treat every record as a definitive taken/available answer.

**Overall:** All-In-One Username Availability Checker delivers a multi platform username checker result set you can export and use right away.

***

### Why All-In-One Username Availability Checker?

There are plenty of ways to pull handle status from different places—here’s why All-In-One Username Availability Checker stands out.

#### One run, many platforms

Instead of checking a username availability tool one site at a time, this actor consolidates results into a single dataset. That’s ideal when you’re building a shortlist of handles across platforms for a launch or brand refresh.

#### Consistent output for faster decision-making

The actor returns a structured dataset with `status` and (when available) `profile_url`. That means you can quickly filter for “Available” and move on to choosing a final handle—no manual cleanup needed.

#### Built for automation and batch planning

Whether you’re running a custom username availability workflow or doing research at scale, this username search tool plugs into your process cleanly via dataset export. It’s also well-suited for automation scenarios where you repeatedly check custom username availability over time.

***

### Real-World Use Cases

Here's how different teams put All-In-One Username Availability Checker to work:

**Brand and Marketing Teams**\
A campaign is on the clock, and the team needs a consistent handle across social channels. They run an all in one username availability checker for a proposed campaign name, then pick the first “Available” handle set to avoid last-minute changes.

**Community Managers**\
When a creator identity shifts (or a handle is changing), community managers need quick confirmation. They use this username availability checker to validate which platforms are taken and which ones are ready for updates.

**Product and Developer Teams**\
Developers often have to reserve names early to keep links and integrations stable. They run this check if username is taken tool as part of planning, then use the dataset’s `platform` and `profile_url` values for internal review.

**Agencies and Growth Partners**\
Agencies support many clients, each with unique handle requirements and timelines. They use a multi platform username checker workflow to deliver handle options and availability summaries across platforms in a single run.

**Freelance Researchers**\
If you’re comparing username availability across communities for a report, you want clean, structured results. This username search tool helps you gather consistent data quickly and export it for analysis without bouncing between sites.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open “All-In-One Username Availability Checker”.
2. **Enter your inputs** — set `keyword` (required) and optionally choose `platform` (or keep `"All"`).
3. **Configure proxy settings (optional)** — if you’re running larger batches, set `proxyConfiguration` to improve reliability.
4. **Start the run** — launch the actor and watch the live log for progress.
5. **Open the Dataset tab** — results appear as the actor completes its checks for each platform.
6. **Export your results** — download from the Apify dataset tab in your preferred format.
7. **Review availability outcomes** — focus on records where `status` is `Available`, and treat `Unknown` for `instagram` and `twitch` as “needs manual verification”.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, All-In-One Username Availability Checker fits directly into your existing workflow. Export your dataset in the Apify dashboard as JSON, CSV, or Excel for analysis, reporting, or client deliverables.

For automation, you can pull results programmatically via the Apify API, or connect your runs to tools using Zapier/Make-style workflows and webhook-style triggers. You can also schedule repeated runs if you want to track changes in handle availability over time.

***

### Pricing

All-In-One Username Availability Checker runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier includes **$5 platform credits on sign-up**, enough for several real test runs.

For ongoing usage, pay-as-you-go is billed per Actor compute unit (CU), and you’ll want to check Apify’s pricing page for details based on your workload. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate limiting and access variability | Supports proxy configuration via `proxyConfiguration`. |
| Unavailable results from specific endpoints | Produces explicit `status` values, including `Unknown` for `instagram` and `twitch`. |
| Occasional request failures | Uses fallback behavior when proxy settings change, and skips platforms that can’t be processed. |
| Mixed-source completeness | Merges results from primary and secondary checks into one dataset. |

**Limitations:** Availability status can vary by platform and by what each endpoint can return. This actor outputs `Unknown` for `instagram` and `twitch`, so you may need manual verification if you require a definitive taken/available determination for those two platforms.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify provides a free tier that includes $5 platform credits on sign-up, which is typically enough for several real test runs.

#### Do I need to log in or create an account on any platform?

No. This actor checks username availability using publicly available information and returns the results in your Apify dataset.

#### How accurate is the extracted data?

The actor returns availability statuses based on what the underlying endpoints can report, including explicit `status` values like `Available`, `Not Available`, and `Unknown` for `instagram` and `twitch`.

#### How many results can I get per run?

When you set `platform` to `"All"`, the actor checks all supported platforms in its list and returns a record per platform it processes. If you choose a specific platform, you’ll only get results for that platform.

#### How fresh is the data?

Data freshness depends on when you run the actor. Each run performs new checks at runtime, so your results reflect the username availability status at the time the actor fetched the data.

#### Is this legal? Does it comply with GDPR / CCPA?

This actor uses **publicly available data**. Whether your specific use case complies with GDPR, CCPA, platform ToS, and applicable local regulations is your responsibility.

#### Can I export to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard. From there, you can import into Google Sheets or other spreadsheet tools.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify actor runs on a cron schedule so your username availability across platforms stays up to date over time.

#### Can I access results via the API?

Yes. You can pull results programmatically via the Apify API after your run finishes.

#### What happens when the actor encounters an error?

If a platform check fails, that platform may be skipped for the run. For `instagram` and `twitch`, the actor still returns records with `status` set to `Unknown` according to its output logic.

***

### Get Help & Use Responsibly

Got a question about All-In-One Username Availability Checker or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with how to structure your runs and ideas like adding more platforms or improving output fields based on your workflow.

**Disclaimer:** This actor collects **publicly available data**. It does not access private accounts, login-gated pages, or password-protected content. You are responsible for ensuring your use complies with GDPR, CCPA, and relevant platform ToS. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A username to search for

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

Select a platform to check. Choose "All" to check every platform.

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keyword": "emilywritespoem",
  "platform": "All"
}
```

# 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 = {
    "keyword": "emilywritespoem"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapedrift/all-in-one-username-availability-checker").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 = { "keyword": "emilywritespoem" }

# Run the Actor and wait for it to finish
run = client.actor("scrapedrift/all-in-one-username-availability-checker").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 '{
  "keyword": "emilywritespoem"
}' |
apify call scrapedrift/all-in-one-username-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapedrift/all-in-one-username-availability-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "All In One Username Availability Checker",
        "description": "🔎 All In One Username Availability Checker checks username availability across platforms instantly. ⚡ Find your perfect handle faster, avoid conflicts, and secure your brand name today. ✅ Fast, easy, and reliable! 🚀✨",
        "version": "1.0",
        "x-build-id": "UOgIs9TIgQO7pdM4X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapedrift~all-in-one-username-availability-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapedrift-all-in-one-username-availability-checker",
                "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/scrapedrift~all-in-one-username-availability-checker/runs": {
            "post": {
                "operationId": "runs-sync-scrapedrift-all-in-one-username-availability-checker",
                "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/scrapedrift~all-in-one-username-availability-checker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapedrift-all-in-one-username-availability-checker",
                "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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Username",
                        "type": "string",
                        "description": "A username to search for",
                        "default": "emilywritespoem"
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "All",
                            "X",
                            "Reddit",
                            "Github",
                            "Medium",
                            "Twitch",
                            "Instagram",
                            "Myanimelist",
                            "Anilist",
                            "Gumroad",
                            "Youtube",
                            "Bluesky",
                            "Linktree",
                            "Kinja",
                            "Mix",
                            "500px",
                            "9gag",
                            "About.me",
                            "Ask.fm",
                            "Bandcamp",
                            "Behance",
                            "Bitbucket",
                            "Blip.fm",
                            "Blogspot",
                            "Bodybuilding",
                            "Buymeacoffee",
                            "Buzzfeed",
                            "Canva",
                            "Cash.app",
                            "Coderwall",
                            "Colourlovers",
                            "Dailymotion",
                            "Deviantart",
                            "Disqus",
                            "Dribbble",
                            "Ebay",
                            "Etsy",
                            "Facebook",
                            "Fiverr",
                            "Flickr",
                            "Flipboard",
                            "Foursquare",
                            "Gamespot",
                            "Goodreads",
                            "Ifttt",
                            "Instructables",
                            "Intensedebate",
                            "Gravatar",
                            "Houzz",
                            "Hubpages",
                            "Kik",
                            "LinkedIn",
                            "Pinterest",
                            "Snapchat",
                            "Tumblr",
                            "Vimeo",
                            "SoundCloud",
                            "Spotify",
                            "StackOverflow",
                            "StackExchange",
                            "Quora",
                            "WhatsApp",
                            "Weibo",
                            "Telegram",
                            "Discord",
                            "TikTok",
                            "Redbubble",
                            "Zomato",
                            "Yelp",
                            "Substack",
                            "Patreon",
                            "OnlyFans",
                            "Vero",
                            "Caffeine",
                            "DLive",
                            "Clubhouse",
                            "Periscope",
                            "Baidu",
                            "Douyin",
                            "VK",
                            "Odnoklassniki",
                            "WeChat",
                            "Line",
                            "Skype",
                            "Zoom",
                            "Google",
                            "Amazon",
                            "Yahoo"
                        ],
                        "type": "string",
                        "description": "Select a platform to check. Choose \"All\" to check every platform.",
                        "default": "All"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
