# Thingiverse Scraper (`automation-lab/thingiverse-scraper`) Actor

Scrape Thingiverse models, creators, tags, licenses, likes, makes, file counts, and 3D-print metadata from searches or model URLs.

- **URL**: https://apify.com/automation-lab/thingiverse-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Thingiverse Scraper

Scrape public Thingiverse search results and model detail pages into a clean Apify dataset.

Use this actor to collect 3D printable model metadata such as model names, URLs, creators, tags, thumbnails, likes, collects, comments, makes, file counts, remix counts, licenses, descriptions, and creation dates.

### What does Thingiverse Scraper do?

Thingiverse Scraper turns public Thingiverse model pages into structured data.

It can:

- 🔎 Search Thingiverse by keyword.
- 🔗 Scrape specific Thingiverse model URLs.
- 🧑‍🎨 Extract creator profile metadata.
- 🏷️ Collect tags and license information.
- 📈 Capture engagement proxies such as likes, collects, comments, and makes.
- 🖼️ Save thumbnails and preview image URLs.
- 🧾 Export results to JSON, CSV, Excel, XML, or via API.

### Who is this Thingiverse scraper for?

This actor is useful for:

- 3D-print marketplace sellers researching printable product ideas.
- Maker teams monitoring popular Thingiverse model categories.
- Hardware startups tracking printable accessory trends.
- Product researchers comparing niches such as phone stands, Raspberry Pi cases, miniatures, or printer calibration models.
- Data teams building dashboards for 3D model popularity and creator activity.

### Why use this actor?

Thingiverse is a large public repository of printable designs, but manually checking search results and detail pages is slow.

This actor helps you:

- Find model ideas faster.
- Compare creators and engagement signals.
- Track tags and license terms for research.
- Build recurring monitoring jobs.
- Feed model metadata into spreadsheets, BI tools, or enrichment pipelines.

### What data can you extract?

| Field | Description |
| --- | --- |
| `thingId` | Thingiverse model ID |
| `name` | Model title |
| `url` | Public Thingiverse model URL |
| `searchQuery` | Keyword that produced the result |
| `sourceType` | `search` or `thing` |
| `position` | Result position in the run |
| `creator` | Creator ID, name, URL, image, verification flags, and profile counts when available |
| `likeCount` | Public like count |
| `collectCount` | Public collect count |
| `commentCount` | Public comment count |
| `makeCount` | Public make count from detail payloads |
| `fileCount` | Number of public files from detail payloads |
| `remixCount` | Remix count from detail payloads |
| `license` | Public license text |
| `tags` | Model tags |
| `descriptionText` | Cleaned model description text |
| `thumbnail` | Thumbnail image URL |
| `previewImage` | Preview image URL |
| `createdAt` | Thingiverse creation timestamp |
| `scrapedAt` | Timestamp when the actor saved the record |

### How much does it cost to scrape Thingiverse?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each model record saved.
- You can keep costs predictable with `maxItems`.

Before publishing, live pricing is calculated from cloud run costs and shown on the Apify Store pricing tab.

### Input options

You can provide one or more of the following:

- `searchQueries` — keywords such as `benchy`, `phone stand`, or `raspberry pi case`.
- `startUrls` — Thingiverse search URLs or model URLs.
- `thingUrls` — direct model URLs or numeric Thingiverse thing IDs.
- `maxItems` — maximum records to save.
- `sort` — search sorting mode.
- `includeDetails` — fetch richer model detail payloads.

### Example input

```json
{
  "searchQueries": ["benchy", "phone stand"],
  "maxItems": 50,
  "sort": "popular",
  "includeDetails": true
}
````

### Scrape a specific Thingiverse model

```json
{
  "thingUrls": ["https://www.thingiverse.com/thing:763622"],
  "maxItems": 1,
  "includeDetails": true
}
```

### Scrape a Thingiverse search URL

```json
{
  "startUrls": [
    { "url": "https://www.thingiverse.com/search?q=benchy&type=things&sort=relevant" }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

### Example output

```json
{
  "searchQuery": "benchy",
  "sourceType": "search",
  "position": 1,
  "thingId": 763622,
  "name": "#3DBenchy - The jolly 3D printing torture-test by CreativeTools.se",
  "url": "https://www.thingiverse.com/thing:763622",
  "creator": {
    "id": 1336,
    "name": "CreativeTools",
    "url": "https://www.thingiverse.com/CreativeTools"
  },
  "likeCount": 90836,
  "collectCount": 138061,
  "commentCount": 994,
  "fileCount": 24,
  "license": "Creative Commons - Public Domain Dedication",
  "tags": ["Benchy", "calibration", "test"],
  "scrapedAt": "2026-06-20T19:49:35.601Z"
}
```

### Step-by-step usage

1. Open the actor on Apify.
2. Add search terms, model URLs, or Thingiverse search URLs.
3. Set `maxItems` to the number of model records you need.
4. Keep `includeDetails` enabled for tags, license, file counts, and descriptions.
5. Run the actor.
6. Download the dataset or connect it to your workflow.

### Tips for better results

- Use specific product nouns such as `phone stand`, `desk organizer`, or `raspberry pi case`.
- Use `popular` sorting when you want demand signals.
- Use `newest` sorting when monitoring fresh uploads.
- Keep `maxItems` low for quick tests.
- Use direct model URLs when you only need a known model.

### Integrations

You can connect the dataset to:

- Google Sheets for model research lists.
- Airtable for maker product pipelines.
- BI dashboards for engagement tracking.
- Webhooks for recurring monitoring.
- AI tools that summarize popular tags and model niches.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/thingiverse-scraper').call({
  searchQueries: ['benchy'],
  maxItems: 20,
  includeDetails: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/thingiverse-scraper').call(run_input={
    'searchQueries': ['benchy'],
    'maxItems': 20,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~thingiverse-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["benchy"],"maxItems":20,"includeDetails":true}'
```

### MCP usage

Use Apify MCP from Claude Code or Claude Desktop with:

```text
https://mcp.apify.com/?tools=automation-lab/thingiverse-scraper
```

Example prompts:

- "Scrape the top 25 Thingiverse results for phone stand models."
- "Extract metadata for this Thingiverse model URL and summarize its license and tags."
- "Compare popular Thingiverse Raspberry Pi case models by likes, collects, and file counts."

### How this actor works

Thingiverse renders search pages with a browser app. The actor starts a browser session, uses the public Thingiverse view API used by the website, and saves normalized model records to the default dataset.

### Data quality notes

Counts are public Thingiverse counters at the time of the run. They may change later. Some optional detail fields depend on the public model payload and may be missing for deleted, moderated, private, or restricted models.

### Troubleshooting

If a run returns fewer models than expected:

- Increase `maxItems`.
- Try a broader search query.
- Use `popular` or `relevant` sorting.
- Confirm that direct URLs are public Thingiverse model pages.

If a specific model URL fails, it may be private, removed, moderated, or temporarily unavailable on Thingiverse.

### Is scraping Thingiverse legal?

This actor extracts public metadata. You are responsible for using the data in a way that respects Thingiverse terms, copyright, licenses, privacy, and applicable laws. Do not use scraped data for spam, abusive automation, or license violations.

### Related scrapers

Other Automation Lab actors that can complement Thingiverse Scraper:

- `automation-lab/kickstarter-scraper` for hardware and maker campaign research.
- `automation-lab/etsy-scraper` for handmade and printable product market research.
- Future MakerWorld, Printables, and 3D model marketplace scrapers can be used for cross-platform comparison.

### FAQ

#### Can I scrape only one Thingiverse model?

Yes. Put the model URL in `thingUrls` and set `maxItems` to `1`.

#### Can I monitor new models?

Yes. Schedule the actor and use `sort: "newest"` with a focused query.

#### Does it download STL files?

No. The actor extracts public model metadata. It does not download model files.

#### Does it require a Thingiverse login?

No. It uses public pages and public view access used by the website.

#### Why do some fields appear empty?

Some models do not expose every field, and search-only runs may have fewer fields when `includeDetails` is disabled.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Thingiverse, such as 3D Benchy, phone stand, or Raspberry Pi case.

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

Optional Thingiverse search URLs or model URLs. Search URLs should contain a q= query parameter; model URLs look like https://www.thingiverse.com/thing:763622.

## `thingUrls` (type: `array`):

Optional direct Thingiverse model URLs or numeric thing IDs to scrape in detail.

## `maxItems` (type: `integer`):

Maximum model records to save across all searches and URLs.

## `sort` (type: `string`):

Thingiverse sorting mode for search queries.

## `includeDetails` (type: `boolean`):

Open model detail API payloads for richer fields such as tags, license, file count, make count, and description text.

## Actor input object example

```json
{
  "searchQueries": [
    "benchy",
    "phone stand"
  ],
  "startUrls": [
    {
      "url": "https://www.thingiverse.com/search?q=benchy&type=things&sort=relevant"
    }
  ],
  "thingUrls": [
    "https://www.thingiverse.com/thing:763622"
  ],
  "maxItems": 20,
  "sort": "relevant",
  "includeDetails": true
}
```

# 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 = {
    "searchQueries": [
        "benchy",
        "phone stand"
    ],
    "startUrls": [
        {
            "url": "https://www.thingiverse.com/search?q=benchy&type=things&sort=relevant"
        }
    ],
    "thingUrls": [
        "https://www.thingiverse.com/thing:763622"
    ],
    "maxItems": 20,
    "sort": "relevant",
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/thingiverse-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": [
        "benchy",
        "phone stand",
    ],
    "startUrls": [{ "url": "https://www.thingiverse.com/search?q=benchy&type=things&sort=relevant" }],
    "thingUrls": ["https://www.thingiverse.com/thing:763622"],
    "maxItems": 20,
    "sort": "relevant",
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/thingiverse-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "benchy",
    "phone stand"
  ],
  "startUrls": [
    {
      "url": "https://www.thingiverse.com/search?q=benchy&type=things&sort=relevant"
    }
  ],
  "thingUrls": [
    "https://www.thingiverse.com/thing:763622"
  ],
  "maxItems": 20,
  "sort": "relevant",
  "includeDetails": true
}' |
apify call automation-lab/thingiverse-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thingiverse Scraper",
        "description": "Scrape Thingiverse models, creators, tags, licenses, likes, makes, file counts, and 3D-print metadata from searches or model URLs.",
        "version": "0.1",
        "x-build-id": "QWlHtvOHz9jwEfrhJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~thingiverse-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-thingiverse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~thingiverse-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-thingiverse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~thingiverse-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-thingiverse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Thingiverse, such as 3D Benchy, phone stand, or Raspberry Pi case.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Thingiverse search or model URLs",
                        "type": "array",
                        "description": "Optional Thingiverse search URLs or model URLs. Search URLs should contain a q= query parameter; model URLs look like https://www.thingiverse.com/thing:763622.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "thingUrls": {
                        "title": "Specific model URLs or IDs",
                        "type": "array",
                        "description": "Optional direct Thingiverse model URLs or numeric thing IDs to scrape in detail.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum models",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum model records to save across all searches and URLs.",
                        "default": 50
                    },
                    "sort": {
                        "title": "Search sort",
                        "enum": [
                            "relevant",
                            "popular",
                            "newest",
                            "makes",
                            "likes"
                        ],
                        "type": "string",
                        "description": "Thingiverse sorting mode for search queries.",
                        "default": "relevant"
                    },
                    "includeDetails": {
                        "title": "Fetch model details",
                        "type": "boolean",
                        "description": "Open model detail API payloads for richer fields such as tags, license, file count, make count, and description text.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```