# Webpage Image Extractor (`fetch_cat/webpage-image-extractor`) Actor

Extract image URLs and metadata from public pages for SEO audits, ecommerce checks, asset migration, and AI image dataset workflows.

- **URL**: https://apify.com/fetch\_cat/webpage-image-extractor.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 image records

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

## Webpage Image Extractor

Extract image URLs and metadata from public web pages. Add one page, a list of pages, or a small same-domain crawl and get a clean dataset of image assets with source page, absolute URL, source type, alt text, dimensions, file type, status code, and byte size when available.

Use it for SEO image audits, ecommerce catalog checks, AI dataset collection, visual-asset migration, and brand monitoring workflows where you need normalized image records rather than screenshots.

### Who is it for?

- SEO teams auditing missing alt text, broken image URLs, large image files, and image coverage across public pages.
- Ecommerce and marketplace operators checking product/category page image assets.
- Content and migration teams inventorying images before CMS, domain, or design changes.
- AI dataset builders collecting public image URL lists with page context.
- Brand and compliance teams monitoring where public sites expose visual assets.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.wikipedia.org/" }
  ],
  "maxPages": 3,
  "maxImages": 50,
  "crawlSameDomain": false,
  "includeSrcset": true,
  "includeCssBackgrounds": false,
  "checkImageStatus": true,
  "downloadImages": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Example output

```json
{
  "pageUrl": "https://www.wikipedia.org/",
  "imageUrl": "portal/wikipedia.org/assets/img/Wikipedia-logo-v2.png",
  "absoluteImageUrl": "https://www.wikipedia.org/portal/wikipedia.org/assets/img/Wikipedia-logo-v2.png",
  "sourceType": "img",
  "alt": "Wikipedia",
  "title": null,
  "width": 200,
  "height": 183,
  "mimeType": "image/png",
  "fileExtension": "png",
  "bytes": 16384,
  "statusCode": 200,
  "discoveredAt": "2026-07-08T09:30:00.000Z"
}
```

### What data it exports

The actor saves one dataset row per discovered image URL.

| Field | Description |
|---|---|
| `pageUrl` | Public page where the image URL was discovered. |
| `imageUrl` | Raw image URL as it appeared in the page. |
| `absoluteImageUrl` | Normalized absolute image URL. |
| `sourceType` | Discovery source: `img`, `srcset`, `meta`, or `css`. |
| `alt` | Image alt text when present. |
| `title` | Image title attribute when present. |
| `width` / `height` | HTML-declared image dimensions when present. |
| `mimeType` | MIME type from the image response when checked. |
| `fileExtension` | File extension parsed from the image URL. |
| `bytes` | File size in bytes when the server provides it or downloads are enabled. |
| `statusCode` | Image URL HTTP status code when checked. |
| `downloadedKey` | Key-value-store key when `downloadImages` saves the file. |
| `discoveredAt` | Timestamp when the image record was produced. |

### Input settings

| Setting | Type | Default | Description |
|---|---:|---:|---|
| `startUrls` | array | required | Public webpage URLs or direct image URLs to inspect. |
| `maxPages` | integer | `3` | Maximum pages to fetch across all start URLs. |
| `maxImages` | integer | `200` | Maximum image records to save. |
| `crawlSameDomain` | boolean | `false` | Follow same-domain links until `maxPages` is reached. |
| `includeSrcset` | boolean | `true` | Include responsive image candidates from `srcset`. |
| `includeCssBackgrounds` | boolean | `false` | Include URLs from inline CSS and page style blocks. |
| `checkImageStatus` | boolean | `true` | Collect image status code, MIME type, and size when available. |
| `downloadImages` | boolean | `false` | Save image files under 15 MB to the run key-value store. |
| `proxyConfiguration` | object | disabled | Optional proxy settings for sites that rate-limit direct traffic. |

### Input recipes

#### Quick image inventory

Use one URL, keep `crawlSameDomain` off, and leave `downloadImages` off. This is best for a fast list of image URLs and metadata.

#### Small website audit

Set `crawlSameDomain` to `true`, `maxPages` to 10-25, and `maxImages` to a reasonable cap. This checks several pages on the same domain without crawling the entire site.

#### Build a downloadable image set

Enable `downloadImages` only when you really need the files. Downloaded files are stored in the run key-value store and referenced by `downloadedKey` in the dataset.

### Pricing

This actor uses pay-per-event pricing:

- Start fee: $0.005 per run.
- Image record: tiered pay-per-result pricing. BRONZE users pay $0.00004 per image record, with lower per-record prices on higher Apify plans.

Keep `maxPages` and `maxImages` low for your first run, then scale after reviewing the output.

### API usage

Run the actor with cURL:

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~webpage-image-extractor/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{ "url": "https://www.wikipedia.org/" }],
    "maxPages": 3,
    "maxImages": 50
  }'
```

Run it with Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/webpage-image-extractor').call({
  startUrls: [{ url: 'https://www.wikipedia.org/' }],
  maxPages: 3,
  maxImages: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Run it with Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/webpage-image-extractor').call(run_input={
    'startUrls': [{ 'url': 'https://www.wikipedia.org/' }],
    'maxPages': 3,
    'maxImages': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

After the run finishes, export the default dataset as JSON, CSV, Excel, XML, RSS, or HTML table from Apify Storage.

### MCP and agents

Use this actor from MCP-compatible tools with:

```text
https://mcp.apify.com/?tools=fetch_cat/webpage-image-extractor
```

Add it to Claude Desktop or Claude Code with:

```bash
claude mcp add apify-webpage-images "https://mcp.apify.com/?tools=fetch_cat/webpage-image-extractor"
```

Example MCP server config:

```json
{
  "mcpServers": {
    "apify-webpage-images": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/webpage-image-extractor"
    }
  }
}
```

Example prompts:

- "Extract image URLs and alt text from this public landing page."
- "Check whether this page has broken image URLs and return status codes."
- "Create a small image dataset from these public documentation pages."

This is useful for agents that need to inspect public pages, collect image URLs, or prepare image datasets as part of a larger workflow.

### Limits and best practices

- Only scan public pages that you are allowed to access.
- The actor does not bypass login walls, CAPTCHA, paywalls, or private content.
- Some websites block automated requests; use proxies only when needed and allowed.
- Very large images are not saved when `downloadImages` is enabled; files over 15 MB are skipped for download safety.
- CSS extraction is optional because CSS can contain icons, tracking pixels, and other assets you may not need.

### Legality and responsible use

Use this actor only on public pages you are allowed to access and process. It does not bypass authentication, CAPTCHA, paywalls, robots restrictions, or private content. Review the target website's terms and applicable privacy, copyright, and data-protection rules before downloading or reusing image files.

### FAQ

#### Can it download the actual images?

Yes. Set `downloadImages` to `true`. The dataset will include `downloadedKey` for files saved to the run key-value store.

#### Can it crawl an entire website?

It can follow same-domain links up to `maxPages`, but it is designed for bounded audits, not unbounded site mirroring. Increase limits gradually.

#### Does it support JavaScript-rendered pages?

The first version focuses on public HTML pages. If a site only renders images after browser JavaScript execution, the actor may return fewer images.

#### Will it extract background images?

Yes, enable `includeCssBackgrounds` to extract `url(...)` references from inline styles and page style blocks.

### Related actors

- [Sitemap URL Extractor](https://apify.com/fetch_cat/sitemap-url-extractor) for discovering pages to feed into image audits.
- [Website Content Crawler Lite](https://apify.com/fetch_cat/website-content-crawler-lite) for text/content extraction from public pages.

### Support

Open an issue on the actor page with the run ID or run URL, your input JSON, expected output, and actual output. This helps reproduce page-specific extraction problems quickly.

### Changelog

- 0.1.0 — Initial version: public-page image URL extraction, srcset/meta/CSS discovery, optional status checks, and optional key-value-store downloads.

# Actor input Schema

## `startUrls` (type: `array`):

Public webpage URLs or direct image URLs to inspect.

## `maxPages` (type: `integer`):

Maximum number of pages to fetch across all start URLs.

## `maxImages` (type: `integer`):

Maximum number of image records to save to the dataset.

## `crawlSameDomain` (type: `boolean`):

Follow links on the same domain until Maximum pages is reached.

## `includeSrcset` (type: `boolean`):

Extract responsive image candidates from srcset attributes.

## `includeCssBackgrounds` (type: `boolean`):

Extract image URLs from inline style attributes and page style blocks.

## `checkImageStatus` (type: `boolean`):

Send a lightweight request to each image URL to collect status code, MIME type, and byte size when available.

## `downloadImages` (type: `boolean`):

Download each image file to the run key-value store when it is under 15 MB. Disabled by default to keep runs cheap.

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

Optional proxy settings for sites that rate-limit datacenter traffic. Leave disabled for public pages that allow direct access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.wikipedia.org/"
    }
  ],
  "maxPages": 3,
  "maxImages": 20,
  "crawlSameDomain": false,
  "includeSrcset": true,
  "includeCssBackgrounds": false,
  "checkImageStatus": true,
  "downloadImages": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.wikipedia.org/"
        }
    ],
    "maxPages": 3,
    "maxImages": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/webpage-image-extractor").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 = {
    "startUrls": [{ "url": "https://www.wikipedia.org/" }],
    "maxPages": 3,
    "maxImages": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/webpage-image-extractor").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 '{
  "startUrls": [
    {
      "url": "https://www.wikipedia.org/"
    }
  ],
  "maxPages": 3,
  "maxImages": 20
}' |
apify call fetch_cat/webpage-image-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/webpage-image-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Webpage Image Extractor",
        "description": "Extract image URLs and metadata from public pages for SEO audits, ecommerce checks, asset migration, and AI image dataset workflows.",
        "version": "0.1",
        "x-build-id": "5wJr8LTkuQy1IKjbt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~webpage-image-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-webpage-image-extractor",
                "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/fetch_cat~webpage-image-extractor/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-webpage-image-extractor",
                "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/fetch_cat~webpage-image-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-webpage-image-extractor",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Public webpage URLs or direct image URLs to inspect.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Public webpage or direct image URL."
                                }
                            }
                        }
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of pages to fetch across all start URLs.",
                        "default": 3
                    },
                    "maxImages": {
                        "title": "Maximum image records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of image records to save to the dataset.",
                        "default": 200
                    },
                    "crawlSameDomain": {
                        "title": "Crawl same-domain links",
                        "type": "boolean",
                        "description": "Follow links on the same domain until Maximum pages is reached.",
                        "default": false
                    },
                    "includeSrcset": {
                        "title": "Include srcset images",
                        "type": "boolean",
                        "description": "Extract responsive image candidates from srcset attributes.",
                        "default": true
                    },
                    "includeCssBackgrounds": {
                        "title": "Include CSS background images",
                        "type": "boolean",
                        "description": "Extract image URLs from inline style attributes and page style blocks.",
                        "default": false
                    },
                    "checkImageStatus": {
                        "title": "Check image status and size",
                        "type": "boolean",
                        "description": "Send a lightweight request to each image URL to collect status code, MIME type, and byte size when available.",
                        "default": true
                    },
                    "downloadImages": {
                        "title": "Download images to key-value store",
                        "type": "boolean",
                        "description": "Download each image file to the run key-value store when it is under 15 MB. Disabled by default to keep runs cheap.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings for sites that rate-limit datacenter traffic. Leave disabled for public pages that allow direct access.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
