# Company Domain to Twitter/X URL Resolver (`automation-lab/company-domain-to-twitter-x-url-resolver`) Actor

🔎 Resolve company domains to Twitter/X profile URLs. Get handles, canonical x.com links, confidence, source pages, context, and errors.

- **URL**: https://apify.com/automation-lab/company-domain-to-twitter-x-url-resolver.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Company Domain to Twitter/X URL Resolver

Resolve company website domains to public Twitter/X profile URLs.

This Apify Actor checks a company homepage and likely about, contact, footer, and company pages, extracts public `x.com` and `twitter.com` profile links, filters share/status/intent URLs, and returns a clean handle plus source evidence.

Use it when you have a spreadsheet of company domains and need social profile URLs for CRM enrichment, Clay workflows, ad audience research, sales ops, recruiting, partner research, or brand monitoring.

### What does Company Domain to Twitter/X URL Resolver do?

It turns inputs like:

```text
shopify.com
stripe.com
notion.so
````

into structured rows with:

```json
{
  "input": "shopify.com",
  "normalizedDomain": "shopify.com",
  "found": true,
  "handle": "Shopify",
  "profileUrl": "https://x.com/Shopify",
  "confidence": "high",
  "sourcePageUrl": "https://www.shopify.com/"
}
```

The actor emits one row per input domain, including not-found rows, so your enrichment pipeline can safely join results back to the original list.

### Who is it for?

- 🧑‍💼 Sales teams enriching lead lists with social URLs
- 📈 Growth marketers building audiences and remarketing research
- 🧲 Clay users converting company domains into social handles
- 🗂️ CRM admins filling missing Twitter/X profile fields
- 🔎 Research teams mapping company social presence
- 🤝 Partnerships teams checking brand social channels
- 📰 PR and monitoring teams tracking official company accounts

### Why use this actor?

Company websites often link their official social profiles in the footer or contact page. This actor uses the website itself as the source of truth instead of guessing from a search page.

That means every match includes evidence:

- 🔗 where the profile URL was found
- 🧾 nearby anchor/context text
- ✅ a confidence label
- 🧭 pages checked for troubleshooting

### What data can you extract?

| Field | Description |
| --- | --- |
| `input` | Original domain or URL from your input |
| `normalizedDomain` | Cleaned company domain |
| `websiteUrl` | Homepage URL checked first |
| `found` | Whether a Twitter/X profile was found |
| `handle` | Twitter/X handle without `@` |
| `profileUrl` | Canonical `https://x.com/{handle}` URL |
| `originalUrl` | Original URL discovered on the website |
| `confidence` | `high`, `medium`, `low`, or `none` |
| `sourcePageUrl` | Page where the profile link was found |
| `matchedAnchorText` | Anchor text on the social link |
| `matchedContext` | Nearby page text around the link |
| `checkedPages` | Website pages crawled for this company |
| `error` | HTTP or validation issue, if any |
| `resolvedAt` | Timestamp of the enrichment row |

### How much does it cost to resolve company domains to Twitter/X URLs?

This actor uses pay-per-event pricing:

- Small start fee per run
- Low per-result fee for each domain row emitted
- Tiered discounts for higher Apify plan tiers

You control cost by controlling the number of input domains and the maximum pages checked per domain.

### How to use the actor

1. Open the actor on Apify.
2. Paste company domains or website URLs into `Domains or company website URLs`.
3. Keep `Maximum pages per domain` at `4` for most enrichment jobs.
4. Run the actor.
5. Download the dataset as CSV, JSON, Excel, or via API.

### Input example

```json
{
  "domains": [
    "shopify.com",
    "stripe.com",
    "notion.so"
  ],
  "maxPagesPerDomain": 4,
  "requestTimeoutSecs": 20
}
```

### Input fields

#### `domains`

A list of company domains or company website URLs.

Accepted examples:

- `shopify.com`
- `https://stripe.com`
- `www.notion.so`

#### `maxPagesPerDomain`

How many pages to check per company.

The actor starts with the homepage and then follows likely internal pages with words such as:

- about
- company
- contact
- connect
- press
- social
- team

#### `requestTimeoutSecs`

Maximum time to wait for each website page.

Use the default unless your target websites are unusually slow.

### Output example

```json
{
  "input": "shopify.com",
  "normalizedDomain": "shopify.com",
  "websiteUrl": "https://shopify.com/",
  "found": true,
  "handle": "Shopify",
  "profileUrl": "https://x.com/Shopify",
  "originalUrl": "https://x.com/Shopify",
  "confidence": "high",
  "sourcePageUrl": "https://www.shopify.com/",
  "matchedAnchorText": "X",
  "matchedContext": "Follow Shopify on X",
  "checkedPages": ["https://www.shopify.com/"],
  "error": null,
  "resolvedAt": "2026-06-24T00:00:00.000Z"
}
```

### Confidence levels

`high` usually means the link appears in social/footer/follow context or appears on a homepage.

`medium` means a valid profile URL was found, but the surrounding context is less explicit.

`low` means a valid profile URL was found with weaker evidence.

`none` means no profile URL was found.

### What URLs are filtered out?

The actor filters URLs that are not company profile pages, including:

- Twitter/X share links
- intent URLs
- status/post URLs
- hashtag pages
- search URLs
- login/account pages
- reserved platform paths

### Tips for better results

- ✅ Use company home domains, not product landing pages, when possible.
- ✅ Increase `maxPagesPerDomain` to `6` or `8` for websites with social links hidden on contact pages.
- ✅ Keep failed rows; they are useful for QA and manual review.
- ✅ Use `sourcePageUrl` and `matchedContext` to audit ambiguous matches.
- ✅ Run batches in chunks if you have a very large list.

### Integrations

Common workflows:

- Clay table enrichment: domain → Twitter/X URL → handle field
- HubSpot enrichment: company domain → official social profile
- Salesforce enrichment: account website → Twitter/X handle
- Airtable monitoring: company list → social profile column
- Google Sheets export: batch domain list → CSV results
- Brand monitoring: company domains → official X accounts to track

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/company-domain-to-twitter-x-url-resolver').call({
  domains: ['shopify.com', 'stripe.com'],
  maxPagesPerDomain: 4,
  requestTimeoutSecs: 20,
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/company-domain-to-twitter-x-url-resolver').call(run_input={
    'domains': ['shopify.com', 'stripe.com'],
    'maxPagesPerDomain': 4,
    'requestTimeoutSecs': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~company-domain-to-twitter-x-url-resolver/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"domains":["shopify.com","stripe.com"],"maxPagesPerDomain":4,"requestTimeoutSecs":20}'
```

### MCP usage

Use this actor from Apify MCP in Claude Code, Claude Desktop, or other MCP clients.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/company-domain-to-twitter-x-url-resolver
```

Claude Code setup:

```bash
claude mcp add apify-company-twitter-resolver https://mcp.apify.com/?tools=automation-lab/company-domain-to-twitter-x-url-resolver
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-company-twitter-resolver": {
      "url": "https://mcp.apify.com/?tools=automation-lab/company-domain-to-twitter-x-url-resolver"
    }
  }
}
```

Example prompts:

- "Resolve these company domains to Twitter/X profile URLs and return a CSV."
- "Find official X handles for the domains in this lead list."
- "Check which of these companies expose Twitter/X profiles on their websites."

### Automation ideas

- Enrich every new CRM account with a Twitter/X profile.
- Monitor newly funded startups for official social channels.
- Build a list of company handles for ads audience research.
- Compare website-linked handles with manually collected handles.
- Flag domains where no official Twitter/X URL is publicly linked.

### Troubleshooting

#### Why did a company return `found: false`?

The company may not link to Twitter/X publicly, may hide links behind JavaScript, may use a link-in-bio page, or may only link social profiles from pages outside the crawl limit.

Try increasing `maxPagesPerDomain`.

#### Why is the profile URL always `x.com`?

The actor canonicalizes valid `twitter.com` and `x.com` profile links to `https://x.com/{handle}` while preserving the discovered URL in `originalUrl`.

#### Can this actor find personal Twitter/X profiles?

It is designed for company website domains and official company social links, not personal-profile discovery.

### Limitations

- Some websites render social links only after JavaScript executes.
- Some brands use regional or support-specific handles.
- Some websites link to social aggregators instead of Twitter/X directly.
- The actor does not log in to X/Twitter.
- The actor does not scrape X/Twitter profile content.

### Legality and responsible use

This actor checks public company websites and extracts public links. It does not bypass logins or collect private account data. Always use the output in accordance with applicable laws, website terms, privacy rules, and your own compliance obligations.

### Related scrapers and enrichment actors

Explore more automation-lab actors on Apify:

- https://apify.com/automation-lab/company-domain-to-instagram-url-resolver
- https://apify.com/automation-lab/domain-to-linkedin-url-resolver
- https://apify.com/automation-lab/website-contact-finder

### FAQ

#### Does it require proxies?

No. The default implementation uses direct HTTP requests to public company websites to keep costs low.

#### Does it charge for not-found rows?

Yes. Each input domain produces a result row, whether found or not, because not-found rows are valuable for list joins and QA.

#### Can I use URLs instead of domains?

Yes. You can pass `https://example.com`, `www.example.com`, or `example.com`.

#### Does it follow every link on the website?

No. It follows a bounded set of likely company/about/contact/social pages to keep runs fast and affordable.

#### Can I export to CSV?

Yes. Apify datasets can be exported to CSV, JSON, Excel, XML, RSS, and via API.

### Support

If you need a different social platform resolver, a broader company social presence mapper, or a custom enrichment workflow, contact the actor maintainer through Apify.

### Changelog

Initial version resolves company domains to Twitter/X URLs from public website links.

### Field notes

The actor is intentionally conservative. It prefers direct website evidence over guessing.

### Batch processing note

For large files, split inputs into manageable batches and keep the default crawl depth first.

### Data quality note

Use confidence, source page, and context fields when reviewing matches.

### Performance note

Most domains finish after the homepage. Extra pages only run when likely internal links are discovered.

# Actor input Schema

## `domains` (type: `array`):

Company domains or URLs to enrich. Use one item per company, for example shopify.com or https://stripe.com.

## `maxPagesPerDomain` (type: `integer`):

How many pages to check per company. The actor starts on the homepage and follows likely about/contact/social links.

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

Maximum time to wait for each company website page.

## Actor input object example

```json
{
  "domains": [
    "shopify.com",
    "stripe.com",
    "notion.so"
  ],
  "maxPagesPerDomain": 4,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "shopify.com",
        "stripe.com",
        "notion.so"
    ],
    "maxPagesPerDomain": 4,
    "requestTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/company-domain-to-twitter-x-url-resolver").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 = {
    "domains": [
        "shopify.com",
        "stripe.com",
        "notion.so",
    ],
    "maxPagesPerDomain": 4,
    "requestTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/company-domain-to-twitter-x-url-resolver").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 '{
  "domains": [
    "shopify.com",
    "stripe.com",
    "notion.so"
  ],
  "maxPagesPerDomain": 4,
  "requestTimeoutSecs": 20
}' |
apify call automation-lab/company-domain-to-twitter-x-url-resolver --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/company-domain-to-twitter-x-url-resolver",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Domain to Twitter/X URL Resolver",
        "description": "🔎 Resolve company domains to Twitter/X profile URLs. Get handles, canonical x.com links, confidence, source pages, context, and errors.",
        "version": "0.1",
        "x-build-id": "Q0eJuP6eZN4hrUFxl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~company-domain-to-twitter-x-url-resolver/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-company-domain-to-twitter-x-url-resolver",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~company-domain-to-twitter-x-url-resolver/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-company-domain-to-twitter-x-url-resolver",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~company-domain-to-twitter-x-url-resolver/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-company-domain-to-twitter-x-url-resolver",
                "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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains or company website URLs",
                        "type": "array",
                        "description": "Company domains or URLs to enrich. Use one item per company, for example shopify.com or https://stripe.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Maximum pages per domain",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many pages to check per company. The actor starts on the homepage and follows likely about/contact/social links.",
                        "default": 4
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum time to wait for each company website page.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```