# DOFFIN Scraper — Norwegian Government Tenders (`studio-amba/doffin-scraper`) Actor

Search and extract Norwegian public procurement tenders from DOFFIN, Norway's official government tender database. Filter by keyword, status, CPV code, date range, or estimated value. Returns tender details, buyer info, deadlines, CPV codes, and documents. No cookies, no login required.

- **URL**: https://apify.com/studio-amba/doffin-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Norwegian Government Tenders Scraper — DOFFIN

Search and extract Norwegian public procurement tenders from DOFFIN (Database for offentlige innkjop), Norway's official national tender database. All Norwegian public authorities are legally required to publish procurement notices above NOK 1.3 million on DOFFIN, making it the single most complete source for Norwegian government contract opportunities.

This actor reads tender data straight from doffin.no's own search backend, the same source that powers the official website. Filter by keyword, tender status, CPV code, location, or publication date range. Returns full tender details including buyer information, deadlines, CPV classification codes, estimated values, and document links. No API key, no cookies, no login required.

### How to scrape DOFFIN data

DOFFIN is operated by DFO (Direktoratet for forvaltning og okonomistyring) on behalf of the Norwegian Ministry of Trade, Industry and Fisheries. This actor queries the same data source as the doffin.no search page — no registration, account, or API key needed. Enter your search keywords, pick optional filters, and run.

#### Who benefits from this data?

- **Government contractors** — Monitor new procurement opportunities daily across all Norwegian municipalities, counties, and central government agencies. Never miss a relevant tender in your industry.
- **Nordic market researchers** — Analyze public spending patterns, procurement volumes, and contract award trends across the Norwegian public sector.
- **B2B sales teams** — Identify which Norwegian government bodies are buying what you sell. Build targeted prospect lists for the NOK 600+ billion annual public procurement market.
- **Consultancies and advisory firms** — Track procurement activity by sector, region, or buyer to advise clients on market entry and bidding strategy.
- **Compliance and legal teams** — Monitor competitor contract awards and verify procurement procedural compliance.
- **EU/EEA market intelligence** — DOFFIN includes all notices that Norway is required to publish on TED (Tenders Electronic Daily) under EEA rules.

#### Search by keyword

Enter any keyword to find relevant tenders. The API searches across tender titles, descriptions, and buyer names. Use Norwegian for best results: "IT-tjenester" (IT services), "bygg" (construction), "renhold" (cleaning), "programvare" (software), "konsulent" (consulting), "helse" (health).

#### Filter by status

- **ACTIVE** — Open tenders you can bid on right now
- **EXPIRED** — Deadline has passed (useful for market research)
- **AWARDED** — Contract has been awarded (competitor intelligence)
- **CANCELLED** — Procurement was cancelled

#### Filter by CPV code

CPV (Common Procurement Vocabulary) codes classify what is being procured. Common codes for Norwegian tenders:
- 72000000 — IT services
- 45000000 — Construction work
- 71000000 — Architectural, engineering, and planning services
- 79000000 — Business services
- 33000000 — Medical equipment and pharmaceuticals
- 60000000 — Transport services

#### Filter by date

Use the `publishedAfter` and `publishedBefore` date filters to monitor new publications or research historical procurement patterns.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | String | `IT-tjenester` | Keywords to search in tender titles, descriptions, and buyer names |
| `tenderStatus` | Enum | `all` | Filter: `all`, `ACTIVE`, `EXPIRED`, `AWARDED`, or `CANCELLED` |
| `cpvCode` | String | — | CPV classification code (e.g., 72000000 for IT services) |
| `location` | String | — | NUTS location code (e.g., NO081 for Oslo, NO0A1 for Rogaland) |
| `publishedAfter` | String | — | Only tenders published on or after this date (YYYY-MM-DD) |
| `publishedBefore` | String | — | Only tenders published on or before this date (YYYY-MM-DD) |
| `maxResults` | Integer | `100` | Maximum number of tenders to return (1-10,000) |
| `proxyConfiguration` | Object | NO residential | Apify proxy settings |

### What data does this scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Tender title / announcement heading |
| `referenceNumber` | String | DOFFIN reference number (e.g., 2026-100282) |
| `organization` | String | Contracting authority / buyer name |
| `status` | String | ACTIVE, EXPIRED, or AWARDED |
| `publicationDate` | String | Date the tender was published |
| `deadline` | String | Bid submission deadline (if applicable) |
| `estimatedValue` | String | Estimated contract value |
| `currency` | String | Currency code (typically NOK) |
| `category` | String | Notice type (contract notice, award notice, etc.) |
| `cpvCodes` | Array | CPV classification codes with descriptions |
| `region` | String | Geographic region in Norway |
| `description` | String | Full tender description |
| `contactInfo` | Object | Contact name, email, phone, URL (when available) |
| `url` | String | Direct link to the tender on doffin.no |
| `scrapedAt` | String | ISO timestamp of when the data was scraped |

### Example output

```json
{
    "title": "Anskaffelse av IT-driftstjenester",
    "referenceNumber": "2026-103456",
    "organization": "Oslo kommune",
    "status": "ACTIVE",
    "publicationDate": "2026-05-20",
    "deadline": "2026-06-30T12:00:00Z",
    "estimatedValue": "15000000",
    "currency": "NOK",
    "category": "Contract notice",
    "cpvCodes": [
        {
            "code": "72000000",
            "description": "IT services: consulting, software development, Internet and support"
        },
        {
            "code": "72500000",
            "description": "Computer-related services"
        }
    ],
    "region": "Oslo",
    "description": "Oslo kommune inviterer til konkurranse om anskaffelse av IT-driftstjenester...",
    "contactInfo": {
        "name": "Innkjopsavdelingen",
        "email": "innkjop@oslo.kommune.no"
    },
    "url": "https://www.doffin.no/notice/2026-103456",
    "scrapedAt": "2026-05-27T14:30:00.000Z"
}
````

### Tips for best results

- **Daily monitoring**: Run on a schedule to catch new tenders within hours of publication. Set `publishedAfter` to yesterday's date for fresh opportunities only.
- **CPV code targeting**: After initial broad searches, note the CPV codes most relevant to your business and use them as filters for precise results.
- **Competitor intelligence**: Search for competitor names or specific service descriptions to track what contracts they are pursuing or winning.
- **Combine with TED**: For full EEA procurement coverage, pair this actor with EU TED data. Larger Norwegian tenders above EU thresholds appear on both DOFFIN and TED.

### How much does it cost to run?

The DOFFIN data source is free. Your only cost is Apify compute time and proxy usage.

| Search size | Estimated time | Estimated cost |
|-------------|---------------|----------------|
| 20 tenders | ~30 seconds | ~$0.01 |
| 100 tenders | ~2 minutes | ~$0.05 |
| 500 tenders | ~10 minutes | ~$0.15 |
| 1,000 tenders | ~20 minutes | ~$0.30 |

Each tender requires one additional API call to fetch full details (CPV codes, contact info), which adds to run time.

### Use as an API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/doffin-scraper").call(run_input={
    "searchQuery": "programvare",
    "tenderStatus": "ACTIVE",
    "maxResults": 50,
})

for tender in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{tender['title']} | {tender['organization']} | Deadline: {tender['deadline']}")
```

### Limitations

- **Deadline may be empty**: Not all notice types have a submission deadline (e.g., prior information notices, voluntary ex-ante transparency notices).
- **Estimated value often absent**: Many tenders do not disclose the estimated contract value in the published notice.
- **Detail fetching adds time**: Each tender gets an individual API call for full details. Set `maxResults` accordingly if you need fast runs.
- **Norwegian text**: Most tender content is in Norwegian. Keyword searches work best with Norwegian terms.

### Other European procurement scrapers

Check the [Studio AMBA actor catalog](https://apify.com/studio-amba) for more European data scrapers, including Dutch (TenderNed), Belgian, and other Nordic procurement portals.

### Your feedback

Found a bug or want a feature? Open an issue on the [Issues tab](https://console.apify.com/actors/studio-amba~doffin-scraper/issues).

# Actor input Schema

## `searchQuery` (type: `string`):

Search tenders by keyword (matched against title, description, and buyer name). Use Norwegian for best results. Examples: 'IT-tjenester', 'bygg', 'renhold', 'programvare', 'konsulent'.

## `tenderStatus` (type: `string`):

Filter by tender status. ACTIVE = open for bids, EXPIRED = deadline passed, AWARDED = contract awarded.

## `cpvCode` (type: `string`):

Filter by CPV (Common Procurement Vocabulary) code. Examples: 72000000 (IT services), 45000000 (construction), 71000000 (architectural services). Leave empty for all categories.

## `location` (type: `string`):

Filter by NUTS location code. Examples: 'NO081' (Oslo), 'NO0A1' (Rogaland), 'NO0A2' (Vestland). Leave empty for all of Norway.

## `publishedAfter` (type: `string`):

Only tenders published on or after this date. Format: YYYY-MM-DD.

## `publishedBefore` (type: `string`):

Only tenders published on or before this date. Format: YYYY-MM-DD.

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

Maximum number of tenders to return.

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

Apify proxy configuration. Norwegian proxies recommended for best reliability.

## Actor input object example

```json
{
  "searchQuery": "IT-tjenester",
  "tenderStatus": "all",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NO"
  }
}
```

# 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 = {
    "searchQuery": "IT-tjenester",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NO"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/doffin-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 = {
    "searchQuery": "IT-tjenester",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NO",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/doffin-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 '{
  "searchQuery": "IT-tjenester",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NO"
  }
}' |
apify call studio-amba/doffin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DOFFIN Scraper — Norwegian Government Tenders",
        "description": "Search and extract Norwegian public procurement tenders from DOFFIN, Norway's official government tender database. Filter by keyword, status, CPV code, date range, or estimated value. Returns tender details, buyer info, deadlines, CPV codes, and documents. No cookies, no login required.",
        "version": "0.0",
        "x-build-id": "KRFKzakh7kvnDJ23w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~doffin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-doffin-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/studio-amba~doffin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-doffin-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/studio-amba~doffin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-doffin-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": {
                    "searchQuery": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Search tenders by keyword (matched against title, description, and buyer name). Use Norwegian for best results. Examples: 'IT-tjenester', 'bygg', 'renhold', 'programvare', 'konsulent'."
                    },
                    "tenderStatus": {
                        "title": "Tender Status",
                        "enum": [
                            "all",
                            "ACTIVE",
                            "EXPIRED",
                            "AWARDED",
                            "CANCELLED"
                        ],
                        "type": "string",
                        "description": "Filter by tender status. ACTIVE = open for bids, EXPIRED = deadline passed, AWARDED = contract awarded.",
                        "default": "all"
                    },
                    "cpvCode": {
                        "title": "CPV Code",
                        "type": "string",
                        "description": "Filter by CPV (Common Procurement Vocabulary) code. Examples: 72000000 (IT services), 45000000 (construction), 71000000 (architectural services). Leave empty for all categories."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by NUTS location code. Examples: 'NO081' (Oslo), 'NO0A1' (Rogaland), 'NO0A2' (Vestland). Leave empty for all of Norway."
                    },
                    "publishedAfter": {
                        "title": "Published After",
                        "type": "string",
                        "description": "Only tenders published on or after this date. Format: YYYY-MM-DD."
                    },
                    "publishedBefore": {
                        "title": "Published Before",
                        "type": "string",
                        "description": "Only tenders published on or before this date. Format: YYYY-MM-DD."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of tenders to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Norwegian proxies recommended for best reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
