# B2B Lead Generation — Intent-Scored & Verified (`jurassic_jove/qualified-lead-finder`) Actor

B2B lead generation that delivers call-ready, intent-scored leads — not raw data. Find businesses by vertical + location (Google Maps) or qualify your own list; detect buying-intent signals (running ads, online booking), verify the owner email, and score each lead 0–100.

- **URL**: https://apify.com/jurassic\_jove/qualified-lead-finder.md
- **Developed by:** [Data Runner](https://apify.com/jurassic_jove) (community)
- **Categories:** Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 qualified lead delivereds

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

## Qualified Lead Finder — Intent-Scored B2B Lead Generation

**B2B lead generation that delivers call-ready leads, not rows of raw data.**

Most lead generation tools hand you a spreadsheet you still have to qualify by
hand. This one finds (or takes) businesses, detects which ones are **already
spending on marketing**, **verifies the owner's email**, and **scores every lead
0–100 by buying intent** — so your sales team calls the hottest leads first.

It's not another tech-stack detector — that market is a race to the bottom.
The value here is the **qualified, verified, intent-scored lead**, ready to call.

> *"Give me 50 HVAC contractors in Tampa who already run ads, with a verified
> email, sorted by intent."* — that's the output. Not a spreadsheet of
> fingerprints you still have to qualify by hand.

---

### Who it's for

- **Marketing & ad agencies** prospecting businesses that already pay for marketing (the warmest possible lead).
- **SDR / outbound teams** who want a pre-qualified, deduplicated, verified call list.
- **Lead-gen operators** who resell qualified leads instead of raw scrapes.

---

### Lead generation in two modes

**Mode A — Discovery** *(find leads from scratch)*
Give it a **vertical + location** (e.g. `"HVAC contractors"` in `"Tampa, FL"`).
It finds the businesses, visits each real website, detects buying-intent
signals, verifies the email, and scores every lead.

**Mode B — Qualify-only** *(you already have a list)*
Give it a list of **domains/URLs**. It skips discovery and just enriches +
scores them. Perfect for cleaning and ranking a list you already own.

*(Provide exactly one: `domains` → Mode B, or `vertical` + `location` → Mode A.)*

---

### The lead score (0–100) — transparent by design

The score **is** the product, so every point is documented and every lead shows
its own `score_breakdown` — you can always audit *why* a lead ranked high.

| Signal | Points | Why it matters |
|---|---:|---|
| `running_ads` | **35** | Already pays for marketing → the strongest buying-intent signal |
| `online_booking` | **20** | Operationally mature; invests in tools |
| `verified_email` | **15** | Actionable — you can actually reach the owner |
| `lead_form` | **10** | Understands the value of a lead |
| `analytics` | **10** | Data-driven mindset |
| `chat_widget` | **5** | Invests in conversion |
| `payment_processor` | **5** | A real transactional business |

`running_ads` carries the most weight on purpose: a business already buying ads
is the warmest lead for a marketing service. `verified_email` counts when the
address is **deliverable** (valid domain, mailbox reachable) — because a great
lead you can't contact isn't a lead.

---

### What you get (one record per lead)

```jsonc
{
  "business_name": "Air Masters of Tampa Bay",
  "domain": "airmasters.net",
  "source_url": "https://airmasters.net/contact",
  "location": "Tampa, FL",
  "vertical": "HVAC contractors",
  "contact": {
    "email": "owner@airmasters.net",
    "email_verified": true,            // deliverable / reachable
    "email_mailbox_confirmed": false,  // stricter: mailbox individually confirmed
    "email_verification_status": "risky",
    "phone": "(813) 555-0100",
    "socials": { "facebook": "https://facebook.com/..." }
  },
  "signals": {
    "running_ads": true,
    "ad_platforms": ["meta", "google"],
    "online_booking": false,
    "analytics": true,
    "lead_form": true,
    "chat_widget": false,
    "stale_site": false,
    "cms": "wordpress",
    "payment_processor": "stripe"
  },
  "lead_score": 70,
  "score_breakdown": { "running_ads": 35, "verified_email": 15, "analytics": 10, "lead_form": 10 },
  "scraped_at": "2026-06-07T12:00:00Z"
}
````

Sort the dataset by `lead_score` and call from the top. Every lead carries a
`source_url` so the data is auditable.

***

### Buying-intent signals we detect

**Buying-intent (from the real, rendered page + its network traffic):**
`running_ads` (Meta / Google / TikTok pixels), `online_booking` (Calendly,
Housecall Pro, Acuity, Square, Jobber, Cal.com…), `analytics` (GA4, GTM, Hotjar,
Clarity, Vercel, Plausible, PostHog, Segment…), `lead_form`, `chat_widget`
(Intercom, Drift, Tawk, Crisp…), `stale_site` (redesign opportunity).

**Business profile (free, from network traffic):** `payment_processor` (Stripe,
Lemon Squeezy, PayPal, Square, Paddle…) and `cms` (WordPress, Shopify, Wix,
Squarespace, Webflow, Framer).

***

### Filters

- `minScore` — only return leads at or above a score (e.g. `50` = only the hot ones).
- `requireSignals` — only leads that have ALL of these (e.g. `["running_ads", "verified_email"]`).
- `verifyEmails` — verify each email's deliverability (on by default).

***

### Input examples

**Mode A — discover:**

```json
{
  "vertical": "HVAC contractors",
  "location": ["Tampa, FL", "Orlando, FL"],
  "maxResults": 50,
  "minScore": 40,
  "verifyEmails": true
}
```

**Mode B — qualify a list:**

```json
{
  "domains": ["acmehvac.com", "https://example-roofing.com"],
  "requireSignals": ["running_ads"],
  "verifyEmails": true
}
```

***

### Pricing

**Pay per qualified lead delivered** — you're charged only for leads that pass
your filters and land in the dataset, not for every attempt. A verified, intent-
scored B2B lead is worth orders of magnitude more than a row of technologies, and
this Actor's price already **absorbs** the discovery and email-verification it
runs under the hood — so you see **one clean price per lead**, not a stack of
charges.

***

### How it works

1. **Discover** (Mode A) or take your `domains` (Mode B).
2. **Visit** each real website with a headless browser (captures the rendered DOM *and* network beacons, so pixels/analytics that never appear in the HTML are still caught).
3. **Detect** intent signals + extract email / phone / socials.
4. **Verify** the email's deliverability.
5. **Score** 0–100 and **filter**, one clean record per lead.

***

### FAQ

**Why don't all leads have an email?**
Many small businesses (home services especially) hide their email behind a
contact form. We still detect that `lead_form` and capture the phone — and the
score reflects reachability honestly. Expect an email on a meaningful share of
leads, not all.

**What does `email_verified: true` mean exactly?**
The address is **deliverable** (valid syntax, the domain accepts mail, not
disposable, not rejected). When the individual mailbox can be confirmed, you'll
also see `email_mailbox_confirmed: true` and `email_verification_status: "good"`.

**Can I just rank a list I already have?**
Yes — that's Mode B. Pass `domains` and skip discovery entirely.

**How do I find businesses that already run Facebook or Google ads?**
Use Mode A with your vertical + location. We detect Meta, Google, and TikTok ad
pixels on each site and flag `running_ads` — then `requireSignals: ["running_ads"]`
returns only businesses already spending on ads (the warmest lead for an agency).

**What industries / verticals does this work for?**
Any local or B2B vertical with a web presence — HVAC, roofing, plumbing,
contractors, dentists, law firms, cleaning services, restaurants, agencies, and
more. Just set the `vertical` and `location`.

# Actor input Schema

## `vertical` (type: `string`):

Mode A (Discovery). Ex: 'HVAC contractors', 'roofing', 'cleaning services'. Required in Mode A — leave empty when passing 'domains'.

## `location` (type: `array`):

Mode A (Discovery). Ex: \['Tampa, FL', 'Orlando, FL']. Required in Mode A.

## `maxResults` (type: `integer`):

Cap on the number of businesses to process in Mode A discovery.

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

Mode B (Qualify-only). A list of domains or URLs. If populated, discovery is skipped and the Actor only enriches + qualifies these.

## `minScore` (type: `integer`):

Output filter: only return leads with lead\_score >= this value.

## `requireSignals` (type: `array`):

Only include leads that have ALL of these signals. Ex: \['running\_ads', 'online\_booking'].

## `verifyEmails` (type: `boolean`):

When on, each discovered email is verified through the Email Verifier & Enricher Pro Actor (deliverability).

## `emailVerifierActorId` (type: `string`):

Actor #1 to call for email verification. Use the technical ID or 'username~actor-name'. Only used when verifyEmails is on.

## `discoveryActorId` (type: `string`):

Google Maps scraper used for Mode A discovery (vertical + location → businesses). Use the technical ID or 'username~actor-name'. Only used in Mode A.

## `discoveryScrapeEmails` (type: `boolean`):

When on, the Maps discovery actor also visits each site to extract emails/socials — better email coverage, but a second crawl (higher cost). When off, only the qualifier visits each site. Mode A only.

## `techDetectActorId` (type: `string`):

Optional external tech-stack detector (CMS, e-commerce, payment processor) — the §5b signals. Leave empty to skip (recommended until a detector is chosen in the smoke-test). Internalizable later.

## Actor input object example

```json
{
  "vertical": "HVAC contractors",
  "location": [
    "Tampa, FL"
  ],
  "maxResults": 50,
  "domains": [
    "apify.com"
  ],
  "minScore": 0,
  "verifyEmails": true,
  "emailVerifierActorId": "email-verifier-enricher-pro",
  "discoveryActorId": "jurassic_jove/google-maps-lead-generator",
  "discoveryScrapeEmails": false,
  "techDetectActorId": ""
}
```

# 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": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jurassic_jove/qualified-lead-finder").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": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("jurassic_jove/qualified-lead-finder").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": [
    "apify.com"
  ]
}' |
apify call jurassic_jove/qualified-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jurassic_jove/qualified-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Lead Generation — Intent-Scored & Verified",
        "description": "B2B lead generation that delivers call-ready, intent-scored leads — not raw data. Find businesses by vertical + location (Google Maps) or qualify your own list; detect buying-intent signals (running ads, online booking), verify the owner email, and score each lead 0–100.",
        "version": "0.0",
        "x-build-id": "HkLFEpHpnyYUFSVPw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jurassic_jove~qualified-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jurassic_jove-qualified-lead-finder",
                "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/jurassic_jove~qualified-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-jurassic_jove-qualified-lead-finder",
                "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/jurassic_jove~qualified-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-jurassic_jove-qualified-lead-finder",
                "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": {
                    "vertical": {
                        "title": "Business vertical (Mode A)",
                        "type": "string",
                        "description": "Mode A (Discovery). Ex: 'HVAC contractors', 'roofing', 'cleaning services'. Required in Mode A — leave empty when passing 'domains'."
                    },
                    "location": {
                        "title": "Location(s) (Mode A)",
                        "type": "array",
                        "description": "Mode A (Discovery). Ex: ['Tampa, FL', 'Orlando, FL']. Required in Mode A.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max businesses (Mode A)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on the number of businesses to process in Mode A discovery.",
                        "default": 50
                    },
                    "domains": {
                        "title": "Domains / URLs to qualify (Mode B)",
                        "type": "array",
                        "description": "Mode B (Qualify-only). A list of domains or URLs. If populated, discovery is skipped and the Actor only enriches + qualifies these.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minScore": {
                        "title": "Minimum lead score (0-100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Output filter: only return leads with lead_score >= this value.",
                        "default": 0
                    },
                    "requireSignals": {
                        "title": "Require these signals",
                        "type": "array",
                        "description": "Only include leads that have ALL of these signals. Ex: ['running_ads', 'online_booking'].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "verifyEmails": {
                        "title": "Verify emails via Actor #1",
                        "type": "boolean",
                        "description": "When on, each discovered email is verified through the Email Verifier & Enricher Pro Actor (deliverability).",
                        "default": true
                    },
                    "emailVerifierActorId": {
                        "title": "Email Verifier Actor ID",
                        "type": "string",
                        "description": "Actor #1 to call for email verification. Use the technical ID or 'username~actor-name'. Only used when verifyEmails is on.",
                        "default": "email-verifier-enricher-pro"
                    },
                    "discoveryActorId": {
                        "title": "Discovery Actor ID (Mode A)",
                        "type": "string",
                        "description": "Google Maps scraper used for Mode A discovery (vertical + location → businesses). Use the technical ID or 'username~actor-name'. Only used in Mode A.",
                        "default": "jurassic_jove/google-maps-lead-generator"
                    },
                    "discoveryScrapeEmails": {
                        "title": "Let discovery scrape emails (Mode A)",
                        "type": "boolean",
                        "description": "When on, the Maps discovery actor also visits each site to extract emails/socials — better email coverage, but a second crawl (higher cost). When off, only the qualifier visits each site. Mode A only.",
                        "default": false
                    },
                    "techDetectActorId": {
                        "title": "Tech detector Actor ID",
                        "type": "string",
                        "description": "Optional external tech-stack detector (CMS, e-commerce, payment processor) — the §5b signals. Leave empty to skip (recommended until a detector is chosen in the smoke-test). Internalizable later.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```