# Fyndiq.se Product Deals Scraper (`automation-lab/fyndiq-se-product-deals-scraper`) Actor

Scrape public Fyndiq.se product deals with prices, discounts, ratings, delivery windows, images and product URLs for ecommerce price monitoring.

- **URL**: https://apify.com/automation-lab/fyndiq-se-product-deals-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Fyndiq.se Product Deals Scraper

Extract product deals from public Fyndiq.se search and category pages.

Use this actor to monitor Swedish marketplace prices, discounts, ratings, delivery windows, product IDs, product URLs, and images without building your own Fyndiq parser.

Fyndiq.se is a large Nordic bargain marketplace.

Sellers, analysts, and price-monitoring teams can use this scraper to follow fast-changing product listings and compare deal positioning across categories.

The actor is HTTP-first and does not require login.

It reads public search result and category listing data.

It saves clean product records to the default dataset.

### What does Fyndiq.se Product Deals Scraper do?

This actor scrapes public product listing data from Fyndiq.se.

It supports keyword searches such as `iphone`, `airpods`, and `mobilskal`.

It also supports Fyndiq category URLs such as `https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/`.

For each product deal, it extracts identifiers, title, URL, image, price, discount, rating, review count, condition, and shipping information when available.

### Who is it for?

🛒 Ecommerce sellers can monitor competing Fyndiq offers.

📊 Marketplace analysts can track product ranges and price bands.

💸 Deal researchers can collect discounted product feeds.

🏷️ Price-monitoring teams can compare current and original prices.

🇸🇪 Nordic growth teams can watch Swedish marketplace demand.

### Why use this scraper?

Fyndiq listings change frequently.

Manual checks are slow and difficult to repeat.

This actor lets you run the same search or category collection on a schedule.

The output is structured and ready for spreadsheets, BI tools, or pricing pipelines.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Search phrase used for the row |
| `inputUrl` | Source category or listing URL |
| `rank` | Position in the run output |
| `productId` | Fyndiq product identifier |
| `articleId` | Fyndiq article/listing identifier |
| `title` | Product title |
| `productUrl` | Absolute Fyndiq product URL |
| `imageUrl` | First product image URL |
| `currentPrice` | Numeric current price |
| `currentPriceFormatted` | Fyndiq-formatted price text |
| `originalPrice` | Original price when exposed |
| `discountPercentage` | Public discount percentage |
| `currency` | Currency, usually SEK |
| `rating` | Average rating when available |
| `reviewCount` | Number of reviews |
| `condition` | Product condition such as refurbished |
| `classifications` | Public classification key-value pairs |
| `expectedDeliveryDate` | Delivery date estimate |
| `shippingSnippet` | Human-readable shipping window |
| `scrapedAt` | ISO scrape timestamp |

### How much does it cost to scrape Fyndiq.se product deals?

This actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-item charge for each product row saved.

You control the maximum number of rows with `maxItems`.

Start with the prefilled input to estimate cost before running larger monitoring jobs.

### Input options

`searchQueries` is the easiest way to collect keyword search results.

`startUrls` accepts Fyndiq search result URLs and category URLs.

`maxItems` limits the total number of product records saved across all inputs.

`sortBy` is set to Fyndiq's default relevance order.

Category URLs also use Fyndiq's page order.

### Example input

```json
{
  "searchQueries": ["iphone", "airpods"],
  "startUrls": [
    { "url": "https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/" }
  ],
  "maxItems": 100,
  "sortBy": "relevance"
}
````

### Output example

```json
{
  "query": "iphone",
  "sourceType": "search",
  "rank": 1,
  "productId": "402f8e85ad98e2a08097b1e5b257f9ee",
  "articleId": "3b7e0fc2-3d6e-4e00-8158-9a6d11584b02",
  "title": "iPhone 15 Pro 128GB Svart Grade A+ Refurbished",
  "productUrl": "https://fyndiq.se/produkt/iphone-15-pro-128gb-svart-grade-a-refurbished-3b7e0fc23d6e4e00",
  "currentPrice": 6499,
  "currentPriceFormatted": "6 499 kr",
  "currency": "SEK",
  "reviewCount": 0,
  "condition": "refurb",
  "shippingSnippet": "1-4 days"
}
```

### How to scrape Fyndiq.se search results

1. Add one or more terms to `searchQueries`.

2. Set `maxItems` to the number of product deals you need.

3. Keep the default `relevance` order for public Fyndiq search results.

4. Run the actor.

5. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### How to scrape Fyndiq.se category pages

1. Open a public Fyndiq category page.

2. Copy the full URL.

3. Add it to `startUrls`.

4. Set `maxItems`.

5. Run the actor.

Category pages are useful for recurring category monitoring.

### Tips for better results

Use Swedish search terms when possible.

Keep `maxItems` small for first tests.

Run separate tasks for separate product families.

Schedule recurring runs to track price changes over time.

Use `productId` and `articleId` as stable keys in your own database.

### Integrations

Connect the dataset to Google Sheets for daily price tracking.

Export JSON to a pricing engine.

Send CSV files to procurement teams.

Use webhooks to trigger downstream alerts when a scheduled run finishes.

Join results with your own SKU catalog by title, product URL, or product ID.

### 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/fyndiq-se-product-deals-scraper').call({
  searchQueries: ['iphone'],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/fyndiq-se-product-deals-scraper').call(run_input={
    'searchQueries': ['iphone'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~fyndiq-se-product-deals-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["iphone"],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/fyndiq-se-product-deals-scraper
```

Claude Code setup:

```bash
claude mcp add apify-fyndiq "https://mcp.apify.com/?tools=automation-lab/fyndiq-se-product-deals-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-fyndiq": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fyndiq-se-product-deals-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Fyndiq iPhone deals and summarize price ranges."

- "Monitor this Fyndiq category URL and return products with discounts."

- "Find Fyndiq products with ratings and current prices for my ecommerce report."

### Scheduling

You can schedule the actor daily, weekly, or hourly depending on your monitoring needs.

For price-change tracking, use the same input each time.

Compare datasets by `productId`, `articleId`, and `currentPrice`.

### Data quality notes

The actor extracts public listing data exposed by Fyndiq.

Some optional fields are missing for some products.

Seller names and brand hints are not always present in public listing payloads.

Delivery dates can change between runs.

### FAQ

#### Can I scrape Fyndiq.se without logging in?

Yes. This actor focuses on public search and category listing data.

#### Does it scrape product detail pages?

The MVP extracts listing-level product deal fields from public search/category payloads. Product detail enrichment can be evaluated later if users need fields not exposed in listings.

#### Why are seller or brand fields missing?

Fyndiq does not reliably expose seller and brand values in the public listing payload used by this HTTP-first actor.

### Troubleshooting

If a run returns fewer items than expected, increase `maxItems` or use broader search terms.

If a category URL returns no items, verify that it is a public Fyndiq.se category page.

If a product has no rating, Fyndiq did not expose a public rating for that listing.

### Legality

This actor extracts publicly available marketplace listing information.

Do not use it to collect private account, checkout, or personal data.

Review your legal basis and Fyndiq's terms before large-scale commercial monitoring.

### Related scrapers

Explore other automation-lab marketplace and deal scrapers on Apify:

- https://apify.com/automation-lab/hotukdeals-scraper

- https://apify.com/automation-lab/mydealz-scraper

- https://apify.com/automation-lab/dealabs-scraper

- https://apify.com/automation-lab/pepper-scraper

### Limits

The actor focuses on public search and category listing data.

It does not log in.

It does not add products to cart.

It does not scrape checkout flows.

It does not guarantee seller fields when Fyndiq does not expose them publicly.

### Best practices

Use one task for each recurring workflow.

Keep inputs specific.

Store historical exports for price trend analysis.

Monitor both keyword searches and important categories.

Validate sampled results before scaling.

### Support

If you need a field that is visible on Fyndiq but missing from the output, open an issue with example URLs.

Include your run ID and expected field.

We can evaluate whether the field is exposed reliably in public page data.

# Actor input Schema

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

Fyndiq search phrases to scrape, for example iphone, airpods, or mobilskal.

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

Optional public Fyndiq.se search URLs (/s/?q=...) or category URLs such as /mobil-surfplattor/iphone-tillbehor/.

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

Maximum number of product records to save across all queries and URLs.

## `sortBy` (type: `string`):

Sort order for keyword searches. The public Fyndiq endpoint currently supports the default relevance order reliably.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone",
    "airpods"
  ],
  "startUrls": [
    {
      "url": "https://fyndiq.se/s/?q=iphone"
    },
    {
      "url": "https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/"
    }
  ],
  "maxItems": 20,
  "sortBy": "relevance"
}
```

# 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": [
        "iphone",
        "airpods"
    ],
    "startUrls": [
        {
            "url": "https://fyndiq.se/s/?q=iphone"
        },
        {
            "url": "https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/"
        }
    ],
    "maxItems": 20,
    "sortBy": "relevance"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fyndiq-se-product-deals-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": [
        "iphone",
        "airpods",
    ],
    "startUrls": [
        { "url": "https://fyndiq.se/s/?q=iphone" },
        { "url": "https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/" },
    ],
    "maxItems": 20,
    "sortBy": "relevance",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fyndiq-se-product-deals-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": [
    "iphone",
    "airpods"
  ],
  "startUrls": [
    {
      "url": "https://fyndiq.se/s/?q=iphone"
    },
    {
      "url": "https://fyndiq.se/mobil-surfplattor/iphone-tillbehor/"
    }
  ],
  "maxItems": 20,
  "sortBy": "relevance"
}' |
apify call automation-lab/fyndiq-se-product-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fyndiq.se Product Deals Scraper",
        "description": "Scrape public Fyndiq.se product deals with prices, discounts, ratings, delivery windows, images and product URLs for ecommerce price monitoring.",
        "version": "0.1",
        "x-build-id": "agTisIhq6igaqdyws"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fyndiq-se-product-deals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fyndiq-se-product-deals-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~fyndiq-se-product-deals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fyndiq-se-product-deals-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~fyndiq-se-product-deals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fyndiq-se-product-deals-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": "Fyndiq search phrases to scrape, for example iphone, airpods, or mobilskal.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Fyndiq search or category URLs",
                        "type": "array",
                        "description": "Optional public Fyndiq.se search URLs (/s/?q=...) or category URLs such as /mobil-surfplattor/iphone-tillbehor/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "📦 Maximum product deals",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product records to save across all queries and URLs.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "↕️ Search sort order",
                        "enum": [
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for keyword searches. The public Fyndiq endpoint currently supports the default relevance order reliably.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```