# UltraFast Discord Username Checker (`spy5/ultrafast-discord-username-checker`) Actor

High-throughput Discord username availability checker with route-capacity mode, structured Apify dataset output, and optional Discord webhook alerts.

- **URL**: https://apify.com/spy5/ultrafast-discord-username-checker.md
- **Developed by:** [spy](https://apify.com/spy5) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 6 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

## UltraFast Discord Username Checker

UltraFast Discord Username Checker checks whether Discord usernames are available or already taken and writes structured results to an Apify dataset. It is built for high-throughput username list validation with Apify residential proxy routes, route-capacity scheduling, browser-like TLS, and optional Discord webhook alerts for available usernames.

Use it when you need an auditable list of Discord username availability results, want to export the data through Apify, or want available usernames pushed to a Discord channel as they are found.

### What can this Actor do?

- Check explicit Discord username lists from a JSON array or pasted text.
- Save every result with `outputMode: "all"` or save mostly available results with `outputMode: "available_only"`.
- Use Apify Proxy residential routes with route-capacity mode for fast batches.
- Retire proxy routes after their configured request capacity to reduce repeated rate-limit waste.
- Send available usernames to a Discord webhook in safe message chunks.
- Log progress counters such as verified, pending, in-flight, rate-limited, deferred, route capacity, and dataset records.
- Support conservative adaptive mode for smaller runs where waiting is preferred over short bursts.

The Actor does not need a Discord login, password, user token, or browser session from your Discord account.

### What data can you extract?

| Field | Description |
| --- | --- |
| `username` | Discord username that was checked. |
| `available` | `true` when Discord reports that the username is available. |
| `status` | Final status such as `available`, `taken`, `invalid_format`, `deferred_rate_limit`, or `deferred_route_capacity`. |
| `statusCode` | Discord HTTP status code when available. |
| `attempts` | Number of request attempts made for the username. |
| `checkedAt` | UTC timestamp when the result was produced. |
| `error` | Diagnostic text for failed or deferred rows. |

### How to check Discord usernames

1. Open the Actor on Apify.
2. Paste usernames into `usernamesText`, one username per line, or provide a JSON `usernames` array.
3. For the first validation run, keep `outputMode` set to `all` so every input has an auditable row.
4. Keep the default fast residential route-capacity settings for high-throughput runs.
5. Optionally set `discordWebhookUrl` or the `DISCORD_WEBHOOK_URL` secret to receive available usernames in Discord.
6. Run the Actor and export results from the default dataset.

Example input:

```json
{
  "usernamesText": "samplecheck0001\nsamplecheck0002\nsamplecheck0003",
  "outputMode": "all",
  "useProxy": true,
  "proxyGroup": "RESIDENTIAL",
  "routeCapacityMode": true,
  "concurrency": 5000,
  "apifyProxyRouteCount": 12000,
  "maxRequestsPerRoute": 1,
  "useBrowserTLS": true
}
````

### Recommended configurations

#### Small validation run

Use this before a large batch. It writes every username to the dataset and makes result auditing easy.

```json
{
  "usernamesText": "samplecheck0001\nsamplecheck0002\nsamplecheck0003",
  "outputMode": "all",
  "useProxy": true,
  "proxyGroup": "RESIDENTIAL",
  "routeCapacityMode": true,
  "concurrency": 500,
  "apifyProxyRouteCount": 1000,
  "maxRequestsPerRoute": 1,
  "useBrowserTLS": true
}
```

#### Fast 5k residential run

Use this after a validation run succeeds. This is the default high-throughput route-capacity style.

```json
{
  "outputMode": "all",
  "useProxy": true,
  "proxyGroup": "RESIDENTIAL",
  "routeCapacityMode": true,
  "adaptiveRateLimit": false,
  "concurrency": 5000,
  "apifyProxyRouteCount": 12000,
  "maxRequestsPerRoute": 1,
  "maxRequestsPerSecond": 0,
  "requestTimeoutSeconds": 5,
  "useBrowserTLS": true,
  "browserTLSProfile": "chrome_133",
  "bootstrapBrowserSession": false
}
```

#### Conservative adaptive run

Use this when you prefer slower, correctness-first behavior over maximum burst speed.

```json
{
  "outputMode": "all",
  "useProxy": true,
  "proxyGroup": "RESIDENTIAL",
  "routeCapacityMode": false,
  "adaptiveRateLimit": true,
  "concurrency": 10,
  "initialRequestsPerMinute": 3,
  "maxRequestsPerMinute": 12,
  "rampEveryVerified": 100,
  "rampStepRequestsPerMinute": 1,
  "cooldownSafetyMultiplier": 1.15,
  "useBrowserTLS": true
}
```

### Discord webhook alerts

Set `discordWebhookUrl` in the input or store it as `DISCORD_WEBHOOK_URL` in Actor secrets. The Actor sends only available usernames to the webhook.

Discord has a message size limit and webhook rate limits. This Actor splits webhook messages into safe chunks and retries webhook 429 responses using Discord's retry timing. Do not publish public tasks or examples with your private webhook URL in the input.

### Pricing and cost expectations

This Actor uses pay-per-event pricing. The current primary result event is charged per item written to the default dataset, and the Actor start event is charged when a run starts. Apify platform usage, residential proxy traffic, dataset storage, and account plan limits may also affect the final run cost.

Cost depends mostly on:

- How many rows are written to the dataset.
- Whether you use `outputMode: "all"` or `outputMode: "available_only"`.
- Whether the run uses residential proxies.
- Whether a batch needs extra attempts because Discord, Cloudflare, or proxy routes return rate limits.
- The `maxTotalChargeUsd` limit you set on the run.

For validation, use `outputMode: "all"`. For production searches where you only need free handles, `available_only` can reduce dataset item charges because taken usernames are not written.

### Troubleshooting

#### Why did my run stop after a cost limit?

Apify can stop a run automatically when it reaches the configured maximum total charge. Increase `maxTotalChargeUsd` only after a small validation run proves the configuration and output are correct.

#### Why do I see rate-limited counters?

Rate-limit counters mean some routes received Discord 429 responses. In route-capacity mode, the Actor can retire those routes and keep verifying usernames through fresh routes. Check `verified`, `unverified`, `deferred_rate_limit`, and `deferred_route_capacity` to know what was actually completed.

#### What does `deferred_route_capacity` mean?

It means the Actor ran out of configured route capacity before verifying that username. Increase `apifyProxyRouteCount`, add more external proxy routes, or run the deferred usernames in a second batch.

#### Why is the Discord webhook not sending?

Discord webhooks can return 429 for rate limits or 403 if the webhook URL is invalid, deleted, or rejected by Discord. Use a valid `discord.com/api/webhooks/...` URL and avoid sharing it in public inputs.

#### Why can I not start new runs?

If Apify reports `Monthly usage hard limit exceeded`, Actor runs, proxy access, storage, and webhooks can be disabled at the account level. Raise or clear the Apify monthly usage limit before starting more runs.

### FAQ

#### Does this Actor log in to Discord?

No. It checks Discord's unauthenticated username availability behavior and does not need your Discord account credentials or token.

#### Can I check very large lists?

Yes, but large lists should be split into batches. Start with a small validation run, then scale the batch size once the logs show that results are being verified and not deferred.

#### Should I use `all` or `available_only` output?

Use `all` while testing so every input is auditable. Use `available_only` when you already trust the configuration and only need available usernames plus exceptional unresolved rows.

#### Can I use my own proxies?

Yes. Add them with `externalProxyUrls` or `externalProxyUrlsText`. Secrets in proxy URLs are redacted from logs.

### Support

If a run looks incomplete, check the final summary log first. The most important counters are `checked`, `verified`, `unverified`, `available`, `taken`, `deferred_rate_limit`, `deferred_route_capacity`, `route_429s`, and `dataset_records`.

# Actor input Schema

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

Explicit lowercase Discord usernames to check. Duplicate values are ignored.

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

Paste newline-separated or comma-separated Discord usernames here instead of using the JSON usernames array. Lines starting with # are ignored.

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

Number of concurrent username checks. Default: 5000 for the measured residential route-capacity preset.

## `maxRetries` (type: `integer`):

Retry attempts for network, Cloudflare, or other non-429 retryable errors. Default: 0 because route-capacity mode retires bad routes and requeues the username.

## `maxRateLimitRetries` (type: `integer`):

Consecutive 429 recovery attempts allowed per username outside route-capacity mode. Default: 1; route-capacity mode requeues usernames onto fresh routes instead.

## `requestTimeoutSeconds` (type: `integer`):

Per-request timeout. Default: 5, measured as the fastest clean 5k setting that still exits with a successful Apify run status.

## `baseBackoffSeconds` (type: `integer`):

Initial retry backoff when Discord does not provide retry\_after. Default: 1.

## `maxBackoffSeconds` (type: `integer`):

Maximum retry backoff. Default: 30.

## `useProxy` (type: `boolean`):

Use Apify Proxy. Default: true for the measured 5k residential route-capacity preset.

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

Optional Apify Proxy group. Default: RESIDENTIAL for high-throughput 5k verification.

## `skipProxyValidation` (type: `boolean`):

Skip the startup Apify Proxy probe and let real Discord requests prove whether each route works. Default: true for speed.

## `forcePublicProxyEndpoint` (type: `boolean`):

Use proxy.apify.com:8000 instead of Apify's in-actor proxy endpoint. Default: true for explicit residential session routes.

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

Optional Apify Proxy country code, for example US or US\_CA.

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

Rotate creates a new session for each proxy URL. Sticky keeps one session for the provider lifetime unless max session age is exceeded. Default: rotate.

## `proxyMaxSessionAgeSeconds` (type: `integer`):

Maximum sticky session age in seconds before rotation. Default: 0 (no age limit).

## `maxRequestsPerSecond` (type: `number`):

Legacy fixed-mode global rate limit in requests per second across all workers. Used only when adaptiveRateLimit is false. 0 disables fixed rate limiting.

## `adaptiveRateLimit` (type: `boolean`):

Use the adaptive single-run scheduler. Default: false for the high-throughput route-capacity preset; enable for conservative low-volume runs.

## `initialRequestsPerMinute` (type: `number`):

Cold-start request launch rate for adaptive mode. Default: 120.

## `maxRequestsPerMinute` (type: `number`):

Maximum adaptive request launch rate after successful ramps. Default: 300.

## `rampEveryVerified` (type: `integer`):

Increase adaptive RPM after this many verified usernames without a global 429 burst. Default: 50.

## `rampStepRequestsPerMinute` (type: `number`):

RPM increase applied at each adaptive ramp. Default: 30.

## `cooldownSafetyMultiplier` (type: `number`):

Multiplier applied to Discord retry\_after for global adaptive cooldowns. Default: 1.15.

## `stopOnGlobalRateLimit` (type: `boolean`):

Stop the run immediately after a non-session Discord shared/global 429 and write unresolved usernames as deferred\_rate\_limit. Default: true to avoid wasting compute on doomed high-rate batches.

## `routeCapacityMode` (type: `boolean`):

Bind request launches to explicit routes and stop using each route before its measured Discord quota is depleted. Default: true.

## `includeDirectRoute` (type: `boolean`):

Use the actor's direct outbound route as one capacity-limited route. Default: false for residential-only 5k runs.

## `directRouteCount` (type: `integer`):

Number of isolated direct browser sessions to use as capacity-limited routes. Each route has its own cookie jar and fingerprint cache. Default: 1.

## `maxRequestsPerRoute` (type: `integer`):

Safe launch budget per route before retiring it. Default: 1, measured fastest for residential route-capacity mode because hot routes are discarded immediately.

## `apifyProxyRouteCount` (type: `integer`):

When useProxy is true, create this many explicit Apify proxy session routes. Default: 12000, the measured clean 5k buffer.

## `externalProxyUrls` (type: `array`):

Optional explicit proxy URLs used as independent capacity-limited routes. Secrets are redacted from logs; route diagnostics only include host and hashes.

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

Paste newline, comma, semicolon, or space separated proxy URLs here instead of using JSON externalProxyUrls.

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

Discord API version for the unauthenticated username attempt endpoint. Default: v10.

## `discordAPIVersions` (type: `array`):

Optional ordered API-version pool for round-robin username checks. Use only for diagnostics; each version must still return a real taken/available verifier response.

## `discordAPIBaseUrls` (type: `array`):

Optional ordered Discord-owned API base URL pool for diagnostics, for example stable, canary, and PTB hosts.

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

Base64-encoded X-Super-Properties header sent to Discord. Defaults to the current Chrome 138 Windows web-build fingerprint bundled with the actor. Update if Discord changes its expected format.

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

Optional X-Fingerprint header value from Discord's unauthenticated experiments endpoint.

## `useBrowserTLS` (type: `boolean`):

Use a Chrome-like TLS and HTTP/2 client profile instead of Go's default HTTP transport. Experimental speed/anti-429 mode.

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

TLS browser profile used when useBrowserTLS is enabled. Default: chrome\_133.

## `enableHTTP3` (type: `boolean`):

Use TLS-client protocol racing so Discord/Cloudflare may select HTTP/3 instead of forcing HTTP/2. Default: false.

## `bootstrapBrowserSession` (type: `boolean`):

Before username checks, reuse browser cookies and the unauthenticated Discord experiments fingerprint for the same session. Default: false; real 5k tests showed bootstrap was slower.

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

Choose all to save every checked username, or available\_only to save only available usernames and reduce dataset storage/export cost.

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

Optional Discord webhook URL. Available usernames are sent in small batches. Prefer DISCORD\_WEBHOOK\_URL for secrets.

## `datasetBatchSize` (type: `integer`):

Maximum number of result records buffered before flushing to the Apify dataset. Default: 1000 for 5k runs.

## `datasetMaxBatchBytes` (type: `integer`):

Maximum estimated JSON payload size buffered before flushing to the Apify dataset. Default: 4194304.

## Actor input object example

```json
{
  "usernames": [
    "availablehandle",
    "takenhandle"
  ],
  "usernamesText": "availablehandle\ntakenhandle",
  "concurrency": 5000,
  "maxRetries": 0,
  "maxRateLimitRetries": 1,
  "requestTimeoutSeconds": 5,
  "baseBackoffSeconds": 1,
  "maxBackoffSeconds": 30,
  "useProxy": true,
  "proxyGroup": "RESIDENTIAL",
  "skipProxyValidation": true,
  "forcePublicProxyEndpoint": true,
  "proxySessionMode": "rotate",
  "proxyMaxSessionAgeSeconds": 0,
  "maxRequestsPerSecond": 0,
  "adaptiveRateLimit": false,
  "initialRequestsPerMinute": 120,
  "maxRequestsPerMinute": 300,
  "rampEveryVerified": 50,
  "rampStepRequestsPerMinute": 30,
  "cooldownSafetyMultiplier": 1.15,
  "stopOnGlobalRateLimit": true,
  "routeCapacityMode": true,
  "includeDirectRoute": false,
  "directRouteCount": 1,
  "maxRequestsPerRoute": 1,
  "apifyProxyRouteCount": 12000,
  "discordAPIVersion": "v10",
  "useBrowserTLS": true,
  "browserTLSProfile": "chrome_133",
  "enableHTTP3": false,
  "bootstrapBrowserSession": false,
  "outputMode": "all",
  "datasetBatchSize": 1000,
  "datasetMaxBatchBytes": 4194304
}
```

# Actor output Schema

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

Checked username results saved to the default dataset.

# 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": [
        "availablehandle",
        "takenhandle"
    ],
    "usernamesText": `availablehandle
takenhandle`
};

// Run the Actor and wait for it to finish
const run = await client.actor("spy5/ultrafast-discord-username-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 = {
    "usernames": [
        "availablehandle",
        "takenhandle",
    ],
    "usernamesText": """availablehandle
takenhandle""",
}

# Run the Actor and wait for it to finish
run = client.actor("spy5/ultrafast-discord-username-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 '{
  "usernames": [
    "availablehandle",
    "takenhandle"
  ],
  "usernamesText": "availablehandle\\ntakenhandle"
}' |
apify call spy5/ultrafast-discord-username-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UltraFast Discord Username Checker",
        "description": "High-throughput Discord username availability checker with route-capacity mode, structured Apify dataset output, and optional Discord webhook alerts.",
        "version": "0.1",
        "x-build-id": "i01Knotzo8scyBIYk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/spy5~ultrafast-discord-username-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-spy5-ultrafast-discord-username-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/spy5~ultrafast-discord-username-checker/runs": {
            "post": {
                "operationId": "runs-sync-spy5-ultrafast-discord-username-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/spy5~ultrafast-discord-username-checker/run-sync": {
            "post": {
                "operationId": "run-sync-spy5-ultrafast-discord-username-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",
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "minItems": 1,
                        "type": "array",
                        "description": "Explicit lowercase Discord usernames to check. Duplicate values are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernamesText": {
                        "title": "Usernames text",
                        "type": "string",
                        "description": "Paste newline-separated or comma-separated Discord usernames here instead of using the JSON usernames array. Lines starting with # are ignored."
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Number of concurrent username checks. Default: 5000 for the measured residential route-capacity preset.",
                        "default": 5000
                    },
                    "maxRetries": {
                        "title": "Max retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for network, Cloudflare, or other non-429 retryable errors. Default: 0 because route-capacity mode retires bad routes and requeues the username.",
                        "default": 0
                    },
                    "maxRateLimitRetries": {
                        "title": "Max rate-limit retries",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Consecutive 429 recovery attempts allowed per username outside route-capacity mode. Default: 1; route-capacity mode requeues usernames onto fresh routes instead.",
                        "default": 1
                    },
                    "requestTimeoutSeconds": {
                        "title": "Request timeout seconds",
                        "minimum": 3,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout. Default: 5, measured as the fastest clean 5k setting that still exits with a successful Apify run status.",
                        "default": 5
                    },
                    "baseBackoffSeconds": {
                        "title": "Base backoff seconds",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Initial retry backoff when Discord does not provide retry_after. Default: 1.",
                        "default": 1
                    },
                    "maxBackoffSeconds": {
                        "title": "Max backoff seconds",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum retry backoff. Default: 30.",
                        "default": 30
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Use Apify Proxy. Default: true for the measured 5k residential route-capacity preset.",
                        "default": true
                    },
                    "proxyGroup": {
                        "title": "Proxy group",
                        "pattern": "^$|^[A-Za-z0-9_-]{1,64}$",
                        "type": "string",
                        "description": "Optional Apify Proxy group. Default: RESIDENTIAL for high-throughput 5k verification.",
                        "default": "RESIDENTIAL"
                    },
                    "skipProxyValidation": {
                        "title": "Skip proxy validation",
                        "type": "boolean",
                        "description": "Skip the startup Apify Proxy probe and let real Discord requests prove whether each route works. Default: true for speed.",
                        "default": true
                    },
                    "forcePublicProxyEndpoint": {
                        "title": "Force public proxy endpoint",
                        "type": "boolean",
                        "description": "Use proxy.apify.com:8000 instead of Apify's in-actor proxy endpoint. Default: true for explicit residential session routes.",
                        "default": true
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "pattern": "^[A-Z]{2}(_[A-Z]{2})?$",
                        "type": "string",
                        "description": "Optional Apify Proxy country code, for example US or US_CA."
                    },
                    "proxySessionMode": {
                        "title": "Proxy session mode",
                        "enum": [
                            "rotate",
                            "sticky"
                        ],
                        "type": "string",
                        "description": "Rotate creates a new session for each proxy URL. Sticky keeps one session for the provider lifetime unless max session age is exceeded. Default: rotate.",
                        "default": "rotate"
                    },
                    "proxyMaxSessionAgeSeconds": {
                        "title": "Proxy max session age seconds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum sticky session age in seconds before rotation. Default: 0 (no age limit).",
                        "default": 0
                    },
                    "maxRequestsPerSecond": {
                        "title": "Max requests per second",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Legacy fixed-mode global rate limit in requests per second across all workers. Used only when adaptiveRateLimit is false. 0 disables fixed rate limiting.",
                        "default": 0
                    },
                    "adaptiveRateLimit": {
                        "title": "Adaptive rate limit",
                        "type": "boolean",
                        "description": "Use the adaptive single-run scheduler. Default: false for the high-throughput route-capacity preset; enable for conservative low-volume runs.",
                        "default": false
                    },
                    "initialRequestsPerMinute": {
                        "title": "Initial requests per minute",
                        "minimum": 0.01,
                        "maximum": 60000,
                        "type": "number",
                        "description": "Cold-start request launch rate for adaptive mode. Default: 120.",
                        "default": 120
                    },
                    "maxRequestsPerMinute": {
                        "title": "Max requests per minute",
                        "minimum": 0.01,
                        "maximum": 60000,
                        "type": "number",
                        "description": "Maximum adaptive request launch rate after successful ramps. Default: 300.",
                        "default": 300
                    },
                    "rampEveryVerified": {
                        "title": "Ramp every verified",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Increase adaptive RPM after this many verified usernames without a global 429 burst. Default: 50.",
                        "default": 50
                    },
                    "rampStepRequestsPerMinute": {
                        "title": "Ramp step requests per minute",
                        "minimum": 0.01,
                        "maximum": 60000,
                        "type": "number",
                        "description": "RPM increase applied at each adaptive ramp. Default: 30.",
                        "default": 30
                    },
                    "cooldownSafetyMultiplier": {
                        "title": "Cooldown safety multiplier",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "number",
                        "description": "Multiplier applied to Discord retry_after for global adaptive cooldowns. Default: 1.15.",
                        "default": 1.15
                    },
                    "stopOnGlobalRateLimit": {
                        "title": "Stop on global rate limit",
                        "type": "boolean",
                        "description": "Stop the run immediately after a non-session Discord shared/global 429 and write unresolved usernames as deferred_rate_limit. Default: true to avoid wasting compute on doomed high-rate batches.",
                        "default": true
                    },
                    "routeCapacityMode": {
                        "title": "Route capacity mode",
                        "type": "boolean",
                        "description": "Bind request launches to explicit routes and stop using each route before its measured Discord quota is depleted. Default: true.",
                        "default": true
                    },
                    "includeDirectRoute": {
                        "title": "Include direct route",
                        "type": "boolean",
                        "description": "Use the actor's direct outbound route as one capacity-limited route. Default: false for residential-only 5k runs.",
                        "default": false
                    },
                    "directRouteCount": {
                        "title": "Direct route count",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Number of isolated direct browser sessions to use as capacity-limited routes. Each route has its own cookie jar and fingerprint cache. Default: 1.",
                        "default": 1
                    },
                    "maxRequestsPerRoute": {
                        "title": "Max requests per route",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safe launch budget per route before retiring it. Default: 1, measured fastest for residential route-capacity mode because hot routes are discarded immediately.",
                        "default": 1
                    },
                    "apifyProxyRouteCount": {
                        "title": "Apify proxy route count",
                        "minimum": 0,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "When useProxy is true, create this many explicit Apify proxy session routes. Default: 12000, the measured clean 5k buffer.",
                        "default": 12000
                    },
                    "externalProxyUrls": {
                        "title": "External proxy URLs",
                        "type": "array",
                        "description": "Optional explicit proxy URLs used as independent capacity-limited routes. Secrets are redacted from logs; route diagnostics only include host and hashes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "externalProxyUrlsText": {
                        "title": "External proxy URLs text",
                        "type": "string",
                        "description": "Paste newline, comma, semicolon, or space separated proxy URLs here instead of using JSON externalProxyUrls."
                    },
                    "discordAPIVersion": {
                        "title": "Discord API version",
                        "enum": [
                            "v6",
                            "v7",
                            "v8",
                            "v9",
                            "v10"
                        ],
                        "type": "string",
                        "description": "Discord API version for the unauthenticated username attempt endpoint. Default: v10.",
                        "default": "v10"
                    },
                    "discordAPIVersions": {
                        "title": "Discord API versions",
                        "type": "array",
                        "description": "Optional ordered API-version pool for round-robin username checks. Use only for diagnostics; each version must still return a real taken/available verifier response.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "discordAPIBaseUrls": {
                        "title": "Discord API base URLs",
                        "type": "array",
                        "description": "Optional ordered Discord-owned API base URL pool for diagnostics, for example stable, canary, and PTB hosts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "superProperties": {
                        "title": "X-Super-Properties header",
                        "type": "string",
                        "description": "Base64-encoded X-Super-Properties header sent to Discord. Defaults to the current Chrome 138 Windows web-build fingerprint bundled with the actor. Update if Discord changes its expected format."
                    },
                    "discordFingerprint": {
                        "title": "Discord fingerprint",
                        "type": "string",
                        "description": "Optional X-Fingerprint header value from Discord's unauthenticated experiments endpoint."
                    },
                    "useBrowserTLS": {
                        "title": "Use browser TLS",
                        "type": "boolean",
                        "description": "Use a Chrome-like TLS and HTTP/2 client profile instead of Go's default HTTP transport. Experimental speed/anti-429 mode.",
                        "default": true
                    },
                    "browserTLSProfile": {
                        "title": "Browser TLS profile",
                        "enum": [
                            "chrome_124",
                            "chrome_133",
                            "chrome_144",
                            "chrome_146"
                        ],
                        "type": "string",
                        "description": "TLS browser profile used when useBrowserTLS is enabled. Default: chrome_133.",
                        "default": "chrome_133"
                    },
                    "enableHTTP3": {
                        "title": "Enable HTTP/3",
                        "type": "boolean",
                        "description": "Use TLS-client protocol racing so Discord/Cloudflare may select HTTP/3 instead of forcing HTTP/2. Default: false.",
                        "default": false
                    },
                    "bootstrapBrowserSession": {
                        "title": "Bootstrap browser session",
                        "type": "boolean",
                        "description": "Before username checks, reuse browser cookies and the unauthenticated Discord experiments fingerprint for the same session. Default: false; real 5k tests showed bootstrap was slower.",
                        "default": false
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "all",
                            "available_only"
                        ],
                        "type": "string",
                        "description": "Choose all to save every checked username, or available_only to save only available usernames and reduce dataset storage/export cost.",
                        "default": "all"
                    },
                    "discordWebhookUrl": {
                        "title": "Discord webhook URL",
                        "type": "string",
                        "description": "Optional Discord webhook URL. Available usernames are sent in small batches. Prefer DISCORD_WEBHOOK_URL for secrets."
                    },
                    "datasetBatchSize": {
                        "title": "Dataset batch size",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of result records buffered before flushing to the Apify dataset. Default: 1000 for 5k runs.",
                        "default": 1000
                    },
                    "datasetMaxBatchBytes": {
                        "title": "Dataset max batch bytes",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum estimated JSON payload size buffered before flushing to the Apify dataset. Default: 4194304.",
                        "default": 4194304
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
