# Username OSINT Scraper (`khadinakbar/username-osint-scraper`) Actor

Find where a username is registered across 480+ websites (Twitter, GitHub, Reddit, TikTok, gaming, dev, NSFW). MCP-ready. $0.04 per username scanned.

- **URL**: https://apify.com/khadinakbar/username-osint-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 username scanned across 480+ sites

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

## Username OSINT Scraper — 480+ Sites in One Scan

**Find every website where a given username is registered.** Drops a single handle (e.g. `gvanrossum`, `khadinakbar`) into 480+ social, dev, gaming, forum, media, and business platforms and returns a structured per-platform map of where the account exists.

Powered by the Sherlock site list (MIT) and a three-mode detector (status code, response text, redirect URL) — the same proven approach used by OSINT investigators, recruiters, and brand-protection teams worldwide. Rewritten in TypeScript for speed, packaged as an MCP-ready Apify actor so AI agents can call it directly with predictable per-username pricing.

### What you get

| Field | Description |
|---|---|
| `username` | The handle that was scanned |
| `platformsChecked` | How many sites were probed for this username |
| `platformsFound` | How many returned a CLAIMED (registered) result |
| `platformsBlocked` | How many returned a WAF / anti-bot response (status uncertain) |
| `scanDurationMs` | Wall-clock duration of the scan |
| `platforms[]` | Per-platform results: site, category, profile URL, status, detection method, HTTP status, NSFW flag |
| `blocked[]` | Sites blocked by Cloudflare/Akamai/PerimeterX/DataDome/AWS-WAF (surfaced honestly rather than guessed) |
| `_note` | Human-readable summary line |

### Pricing

- `apify-actor-start` — $0.00005 per run (Apify-standard start fee)
- `username-scanned` — **$0.04 per username processed** (covers the full 480+ site scan, regardless of how many platforms match)

A typical 1-username scan costs ~$0.04. A 10-username batch costs ~$0.40. Pay-Per-Usage is also enabled if you prefer compute-based billing for huge jobs.

### Quick start

#### From Apify Console
1. Open the actor.
2. Paste one or more usernames into the `usernames` field.
3. (Optional) Toggle `includeNSFW`, pick `categories`, adjust `concurrency`.
4. Click **Start**.

#### From the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~username-osint-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "usernames": ["khadinakbar", "gvanrossum"],
    "includeAvailable": false,
    "includeNSFW": false
  }'
````

#### From the Apify JS client

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/username-osint-scraper').call({
  usernames: ['khadinakbar'],
  categories: ['social', 'dev'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].platforms.filter(p => p.status === 'CLAIMED'));
```

#### From an MCP client (Claude / GPT / Cursor)

Add Apify MCP to your client (`https://mcp.apify.com`). The tool surfaces as `apify-actor-username-osint-scraper`. Agents call it the same way they call any other tool — the input schema and 4-sentence field descriptions let the LLM choose parameters correctly.

### Example output

```json
{
  "username": "gvanrossum",
  "scanStartedAt": "2026-05-16T18:30:00.000Z",
  "platformsChecked": 481,
  "platformsFound": 23,
  "platformsBlocked": 4,
  "scanDurationMs": 27310,
  "platforms": [
    { "site": "GitHub", "category": "dev", "url": "https://www.github.com/gvanrossum", "status": "CLAIMED", "detectionMethod": "status_code", "httpStatus": 200, "isNSFW": false },
    { "site": "Hugging Face", "category": "dev", "url": "https://huggingface.co/gvanrossum", "status": "CLAIMED", "detectionMethod": "status_code", "httpStatus": 200, "isNSFW": false },
    { "site": "Replit.com", "category": "dev", "url": "https://replit.com/@gvanrossum", "status": "CLAIMED", "detectionMethod": "status_code", "httpStatus": 200, "isNSFW": false }
  ],
  "blocked": [
    { "site": "Instagram", "url": "https://instagram.com/gvanrossum", "reason": "WAF-Cloudflare" }
  ],
  "_note": "23 platforms found. 481 checked. 4 WAF/anti-bot blocked (status uncertain)."
}
```

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `usernames` | string\[] | **required** | Plain handles to look up. Max 100 per run. No `@` symbol, no full URLs. |
| `includeAvailable` | boolean | `false` | If true, also returns platforms where the username is NOT registered. Useful when checking availability before registering on multiple platforms. |
| `includeNSFW` | boolean | `false` | If true, scans 19 adult/NSFW platforms. Off by default for general OSINT work. |
| `categories` | string\[] | `[]` (all) | Restrict scan to: `social`, `dev`, `gaming`, `forum`, `media`, `business`, `other`. Empty array scans everything. |
| `concurrency` | int | `40` | Parallel HTTP requests per chunk. Raise to 80 with extra RAM, lower to 20 on slow networks. |
| `requestTimeoutSecs` | int | `15` | Per-request timeout. |
| `proxyConfiguration` | object | Apify Residential | Proxy settings. Default: Apify residential — best success rate against WAF-protected platforms. |

### How detection works

The actor uses Sherlock's proven three-mode detector:

- **`status_code`** — Some platforms (GitHub, Reddit) return distinct HTTP codes for existing vs missing profiles. We check the code and apply the platform-specific rule.
- **`message`** — Some platforms (e.g. Reddit) return 200 for every profile URL but include a distinct error phrase in the body when the user does not exist. We string-match the response.
- **`response_url`** — Some platforms redirect missing usernames to a home/search page. We disable redirects and check whether the response stayed at the expected profile URL.

When a platform returns a Cloudflare / Akamai / PerimeterX / DataDome / AWS-WAF challenge, we mark the result as `WAF` rather than guess. This is the honest answer — false-positive WAF guesses cost OSINT investigators real time.

### FAQ

**Does it work for any username?**
Most. Some platforms enforce username format rules (length, allowed characters); the actor honours each platform's `regexCheck` and silently skips platforms where the input cannot be a valid handle.

**Why not just use the open-source Sherlock CLI?**
Three reasons: (1) you get an Apify actor URL you can call from any agent, API, or Zap — no Python install. (2) Residential proxies on by default — Sherlock's defaults get blocked. (3) MCP-ready: AI agents see structured input/output schemas, predictable per-username pricing, and machine-readable WAF flags they can act on.

**How accurate is it?**
Detection follows Sherlock's three-mode model exactly. Known false-positive sites (those that return 200 for every profile URL) use the `message` mode to validate against a real "user not found" string. Heavily WAF-protected sites are surfaced honestly as `WAF` rather than guessed.

**Can I run it on a list of suspect handles for fraud / brand protection?**
Yes — pass up to 100 usernames per run. The `_note` field includes a one-line summary; cross-cluster repeat hits (same handle on Tinder + LinkedIn + GitHub + niche forums) is a strong identity signal.

**What categories does it cover?**

- **social** — Twitter, Instagram, TikTok, Reddit, Mastodon, Bluesky, LinkedIn, Threads, etc.
- **dev** — GitHub, GitLab, npm, PyPI, Hugging Face, Replit, Codepen, Stack Overflow, Kaggle, etc.
- **gaming** — Steam, Xbox, PlayStation, Twitch, Chess.com, Lichess, etc.
- **forum** — Quora, Discord public profile, 4chan, Hacker News, Stack Exchange, etc.
- **media** — Spotify, YouTube, Vimeo, Bandcamp, Behance, Dribbble, DeviantArt, Letterboxd, Goodreads, Medium, Substack, etc.
- **business** — Patreon, Fiverr, Upwork, Crunchbase, Product Hunt, Ko-fi, Kickstarter, etc.
- **other** — Everything else in the Sherlock catalogue.

**What about NSFW sites?**
The Sherlock catalogue includes 19 adult platforms. They are excluded by default; toggle `includeNSFW: true` only for compliance, brand-protection, or fraud-investigation workflows.

**How long does a scan take?**
Typical 1-username scan over all 480+ sites: 20–40 seconds with `concurrency: 40`. Single-category scans (e.g., `categories: ['dev']`) finish in 5–15 seconds.

### Complementary actors

If you found a username on LinkedIn, GitHub, or Twitter via this scanner, enrich the result with:

- [LinkedIn Profile Scraper & Email Finder](https://apify.com/khadinakbar/linkedin-profile-email-scraper) — pull the full profile + verified email.
- [Twitter/X Profile & Followers Scraper](https://apify.com/khadinakbar/twitter-profile-followers-scraper) — extract tweets, followers, profile metadata.
- [Bulk Website Contact Extractor](https://apify.com/khadinakbar/bulk-website-contact-extractor) — once you have a personal site, pull emails / phones / social links.

### Legal / ethical notice

This actor only checks publicly available profile URLs — it does not bypass authentication, scrape private data, or access content gated behind a login. Use it for legitimate OSINT, brand protection, fraud detection, recruiting, and journalism. Do not use it to stalk, harass, dox, or target individuals.

Each platform's terms of service apply to how you use the data returned. You are responsible for ensuring your use complies with applicable privacy laws (GDPR, CCPA, etc.) and platform policies.

Site catalogue derived from the open-source [Sherlock project](https://github.com/sherlock-project/sherlock) (MIT License). Detection methodology described in the [Sherlock README](https://github.com/sherlock-project/sherlock).

### Changelog

- **0.1 (2026-05-16)** — Initial release. 481 sites from Sherlock data.json. Three-mode detector. WAF detection for Cloudflare/Akamai/PerimeterX/DataDome/AWS-WAF. Category auto-tagging. NSFW filter. PPE: $0.04 per username scanned + Apify Pay-Per-Usage option.

# Actor input Schema

## `usernames` (type: `array`):

List of usernames to look up across 480+ sites. Each username triggers one parallel scan and one billable event. Plain handles only (no @ symbol or full URLs). Example: \['khadinakbar', 'gvanrossum']. NOT email addresses — for email-based lookups use the email-address-validator actor.

## `includeAvailable` (type: `boolean`):

If true, the output includes platforms where the username is NOT registered (status: AVAILABLE) in addition to CLAIMED ones. Defaults to false (CLAIMED only — the typical OSINT investigation use case). Set to true for username-availability checks before registering on multiple platforms.

## `includeNSFW` (type: `boolean`):

If true, scans the 19 adult-oriented platforms in the site list (PornHub, OnlyFans, etc.). Defaults to false. Set to true only for compliance, brand-protection, or fraud-investigation workflows where adult-site presence is part of the investigation.

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

Restrict the scan to specific categories of sites to reduce runtime and surface only relevant platforms. Empty array (default) scans all categories. Available: social, dev, gaming, forum, media, business, other. Example: \['social','dev'] scans only social and developer platforms.

## `concurrency` (type: `integer`):

Number of parallel HTTP requests across the site list. Higher = faster but more memory. Defaults to 40 (good for 512MB actor). Increase to 80 only if you bump the actor memory; reduce to 20 on slow networks. NOT the number of usernames in parallel — each username is processed sequentially.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for any single site response before marking it as TIMEOUT. Defaults to 15. Decrease to 8 for a faster but more lossy scan; increase to 30 if you see many slow sites in the WARNING logs. Per-request, not per-username.

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

Apify proxy configuration. Defaults to Apify residential proxies for the best success rate against WAF-protected sites. Override only if you have specific proxy needs.

## Actor input object example

```json
{
  "usernames": [
    "gvanrossum"
  ],
  "includeAvailable": false,
  "includeNSFW": false,
  "categories": [],
  "concurrency": 40,
  "requestTimeoutSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

JSON dataset, one item per scanned username, with full per-platform breakdown.

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

Same dataset as above, flattened to CSV.

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

Aggregate run-level numbers: total usernames processed, total platform hits, runtime, applied filters.

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

Direct link to the run page for inspection of logs, dataset, KV state.

# 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 = {
    "usernames": [
        "gvanrossum"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/username-osint-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 = {
    "usernames": ["gvanrossum"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/username-osint-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 '{
  "usernames": [
    "gvanrossum"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/username-osint-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Username OSINT Scraper",
        "description": "Find where a username is registered across 480+ websites (Twitter, GitHub, Reddit, TikTok, gaming, dev, NSFW). MCP-ready. $0.04 per username scanned.",
        "version": "0.3",
        "x-build-id": "ISqgmdeNt9yrtJqL8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~username-osint-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-username-osint-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/khadinakbar~username-osint-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-username-osint-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/khadinakbar~username-osint-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-username-osint-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames to scan",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of usernames to look up across 480+ sites. Each username triggers one parallel scan and one billable event. Plain handles only (no @ symbol or full URLs). Example: ['khadinakbar', 'gvanrossum']. NOT email addresses — for email-based lookups use the email-address-validator actor.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 64
                        }
                    },
                    "includeAvailable": {
                        "title": "Include AVAILABLE results",
                        "type": "boolean",
                        "description": "If true, the output includes platforms where the username is NOT registered (status: AVAILABLE) in addition to CLAIMED ones. Defaults to false (CLAIMED only — the typical OSINT investigation use case). Set to true for username-availability checks before registering on multiple platforms.",
                        "default": false
                    },
                    "includeNSFW": {
                        "title": "Include adult/NSFW sites",
                        "type": "boolean",
                        "description": "If true, scans the 19 adult-oriented platforms in the site list (PornHub, OnlyFans, etc.). Defaults to false. Set to true only for compliance, brand-protection, or fraud-investigation workflows where adult-site presence is part of the investigation.",
                        "default": false
                    },
                    "categories": {
                        "title": "Site categories to scan (empty = all)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict the scan to specific categories of sites to reduce runtime and surface only relevant platforms. Empty array (default) scans all categories. Available: social, dev, gaming, forum, media, business, other. Example: ['social','dev'] scans only social and developer platforms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "social",
                                "dev",
                                "gaming",
                                "forum",
                                "media",
                                "business",
                                "other"
                            ]
                        },
                        "default": []
                    },
                    "concurrency": {
                        "title": "Concurrent requests",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of parallel HTTP requests across the site list. Higher = faster but more memory. Defaults to 40 (good for 512MB actor). Increase to 80 only if you bump the actor memory; reduce to 20 on slow networks. NOT the number of usernames in parallel — each username is processed sequentially.",
                        "default": 40
                    },
                    "requestTimeoutSecs": {
                        "title": "Per-request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum seconds to wait for any single site response before marking it as TIMEOUT. Defaults to 15. Decrease to 8 for a faster but more lossy scan; increase to 30 if you see many slow sites in the WARNING logs. Per-request, not per-username.",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Defaults to Apify residential proxies for the best success rate against WAF-protected sites. Override only if you have specific proxy needs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
