# FINN.no Jobs Scraper (`automation-lab/finn-no-jobs-scraper`) Actor

Scrape public FINN.no job listings with titles, companies, locations, deadlines, salaries, descriptions, and URLs.

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

## Pricing

from $0.06 / 1,000 result extracteds

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

## FINN.no Jobs Scraper 🇳🇴💼

Extract structured job listings from FINN.no, Norway's largest classifieds marketplace and a major source of public Norwegian job ads.

Use this actor to collect job titles, companies, locations, published dates, application deadlines, salaries when shown, easy-apply flags, descriptions, and listing URLs from public FINN.no job search pages.

### What does FINN.no Jobs Scraper do?

FINN.no Jobs Scraper turns public FINN.no job search pages into clean dataset rows.

It can:

- 🔎 Search by keyword such as `sykepleier`, `developer`, or `marketing`
- 🔗 Accept direct FINN.no `/job/search` URLs with filters
- 📄 Paginate through search results until your `maxItems` limit is reached
- 🧾 Fetch job detail pages for descriptions and richer metadata
- 📍 Capture location and coordinate data when FINN.no provides it
- 💰 Capture salary or hourly wage fields when visible on the job ad
- ✅ Detect easy-apply listings
- 📦 Export results as JSON, CSV, Excel, XML, RSS, or HTML table from Apify

### Who is it for?

This scraper is useful for several personas:

- Recruiters monitoring competitors and high-demand roles
- Staffing agencies building Norwegian vacancy intelligence
- Job aggregators collecting fresh listings for downstream products
- Labor-market analysts tracking hiring trends by company, title, and region
- HR teams benchmarking advertised salaries and open roles
- Data teams feeding dashboards, alerts, and NLP pipelines

### Why use this actor?

FINN.no has rich public job data, but manually copying listings is slow and error-prone.

This actor provides:

- 🚀 Fast HTTP extraction without a heavy browser
- 🧩 Structured fields ready for analytics
- 🔁 Repeatable runs for scheduled monitoring
- 🧠 Optional full descriptions for AI classification and enrichment
- 🧰 Apify integrations for datasets, webhooks, APIs, and MCP tools

### Data extracted

| Field | Description |
| --- | --- |
| `adId` | FINN.no job ad ID |
| `url` | Direct public job ad URL |
| `title` | Job title used for display |
| `heading` | Full listing heading |
| `companyName` | Employer name |
| `jobTitle` | FINN.no job title/category field |
| `location` | Primary location |
| `locations` | Location hierarchy from search result |
| `publishedAt` | Published timestamp/date when available |
| `applicationDeadline` | Deadline from the detail page when available |
| `employmentType` | Employment type from structured job data |
| `salary` | Salary/hourly wage when disclosed |
| `noOfPositions` | Number of positions when disclosed |
| `easyApply` | Whether FINN easy apply is shown |
| `labels` | FINN labels such as easy apply |
| `latitude` / `longitude` | Coordinates when provided |
| `sector` | Employer sector from detail page |
| `industry` | Industry from detail page |
| `occupation` | Job function from detail page |
| `workingLanguages` | Listed working languages |
| `keywords` | Keywords shown on the ad |
| `descriptionText` | Plain-text job description |
| `descriptionHtml` | HTML job description |
| `searchUrl` | Search page that produced the listing |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape FINN.no jobs?

The actor uses pay-per-event pricing.

You pay a small start fee per run and a per-result fee for each saved job listing. Exact live pricing is shown on the Apify Store page before you run the actor.

Tips for keeping costs low:

- Start with a small `maxItems` value
- Turn off `includeDetails` if search-result fields are enough
- Use a specific keyword or filtered FINN.no URL
- Schedule smaller recurring runs instead of one very broad run

### How to use FINN.no Jobs Scraper

1. Open the actor on Apify.
2. Enter a keyword or paste one or more FINN.no job search URLs.
3. Set `maxItems` to the number of listings you need.
4. Keep `includeDetails` enabled if you need descriptions, salary, deadlines, and extra metadata.
5. Click **Start**.
6. Download the dataset or connect it to your workflow.

### Input example

```json
{
  "query": "sykepleier",
  "maxItems": 25,
  "sort": "PUBLISHED_DESC",
  "includeDetails": true
}
````

### Direct URL input example

```json
{
  "startUrls": [
    { "url": "https://www.finn.no/job/search?q=developer&sort=PUBLISHED_DESC" }
  ],
  "maxItems": 50,
  "includeDetails": true
}
```

### Output example

```json
{
  "adId": 452696347,
  "url": "https://www.finn.no/job/ad/452696347",
  "title": "Elektriker/Svakstrømsmontør",
  "companyName": "Brannslokkesystemer AS",
  "location": "Sofiemyr",
  "publishedAt": "2026-06-11T08:09:48.000Z",
  "applicationDeadline": "Snarest",
  "salary": "370 - 400 kr NOK HOUR",
  "easyApply": true,
  "descriptionText": "Brannslokkesystemer AS er et solid selskap...",
  "scrapedAt": "2026-06-11T08:20:00.000Z"
}
```

### Search tips

- Use Norwegian keywords for best coverage.
- Paste filtered FINN.no URLs when you need region, occupation, or industry filters.
- Use `PUBLISHED_DESC` for monitoring fresh postings.
- Use `RELEVANCE` when exploring broad keywords.
- Keep `maxItems` low during test runs.

### Detail page enrichment

When `includeDetails` is enabled, the actor visits each job ad URL and extracts additional public fields from JSON-LD and HTML labels.

This may include:

- Full description
- Application deadline
- Salary or hourly wage
- Employment type
- Sector
- Industry
- Job function
- Working languages
- Keywords

Disable detail fetching if you only need fast search-result metadata.

### Integrations

Use Apify integrations to connect FINN.no jobs data to your systems:

- Send new listings to Google Sheets
- Trigger webhooks when a scheduled run finishes
- Load datasets into BigQuery, Snowflake, or S3
- Feed job descriptions into an LLM classification workflow
- Monitor company hiring trends in a dashboard

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/finn-no-jobs-scraper').call({
  query: 'developer',
  maxItems: 50,
  includeDetails: true,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/finn-no-jobs-scraper').call(run_input={
    'query': 'sykepleier',
    'maxItems': 25,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~finn-no-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"marketing","maxItems":25,"includeDetails":true}'
```

### MCP usage

You can use this actor through Apify MCP in Claude Code or Claude Desktop.

MCP server URL:

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

Add it in Claude Code with:

```bash
claude mcp add apify-finn-jobs https://mcp.apify.com/?tools=automation-lab/finn-no-jobs-scraper
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-finn-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/finn-no-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Find the newest nursing jobs on FINN.no and summarize the top employers."
- "Scrape 50 developer jobs from FINN.no and group them by city."
- "Get FINN.no job ads for marketing roles and extract salary mentions."

### Scheduling

For monitoring workflows, schedule the actor daily or weekly.

Recommended setup:

- Use `sort=PUBLISHED_DESC`
- Use focused keywords or filtered URLs
- Store previous datasets for comparison
- Trigger a webhook after each run

### Data quality notes

FINN.no listings vary by employer. Some ads include salary, deadline, and detailed taxonomy; others omit one or more of those fields.

The actor returns `null` or an empty array when a public field is not present.

### Troubleshooting

#### Why are salary fields empty?

Many employers do not publish salary ranges. The actor only returns salary when FINN.no shows it publicly.

#### Why did I get fewer items than requested?

Your keyword or filtered URL may have fewer public listings than `maxItems`, or FINN.no may cap paging for that query.

#### Should I enable detail pages?

Enable detail pages for descriptions and richer metadata. Disable them for faster, cheaper discovery runs.

### Legality

This actor extracts publicly available job listing data from FINN.no. You are responsible for using the data in compliance with applicable laws, FINN.no terms, privacy rules, and your own legal obligations.

Do not scrape private account data, bypass access controls, or use the output for prohibited purposes.

### Related scrapers

Explore other automation-lab actors for recruitment and market intelligence:

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-jobs-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/trustpilot-scraper

### FAQ

#### Can I scrape a specific FINN.no filtered search?

Yes. Paste the filtered `/job/search` URL into `startUrls`.

#### Does the actor need a FINN.no account?

No. It uses public search and job ad pages.

#### Does it use a browser?

No. The actor is HTTP-only for lower cost and faster runs.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, and HTML.

#### Can I monitor new jobs every day?

Yes. Use Apify schedules with newest-first sorting and a focused query.

### Changelog

- Initial version: public FINN.no job search scraping with optional detail page enrichment.

# Actor input Schema

## `query` (type: `string`):

Optional FINN job search keyword, for example `sykepleier`, `developer`, or `marketing`.

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

Optional direct FINN.no `/job/search` URLs with filters. If provided, these are used instead of the keyword search.

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

Maximum number of job listings to save.

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

FINN.no sort order for keyword searches.

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

Fetch each job ad page to include description, salary, application deadline, sector, industry, occupation, languages, and keywords. Slower but richer.

## Actor input object example

```json
{
  "query": "sykepleier",
  "startUrls": [
    {
      "url": "https://www.finn.no/job/search?q=sykepleier&sort=PUBLISHED_DESC"
    }
  ],
  "maxItems": 20,
  "sort": "PUBLISHED_DESC",
  "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 = {
    "query": "sykepleier",
    "startUrls": [
        {
            "url": "https://www.finn.no/job/search?q=sykepleier&sort=PUBLISHED_DESC"
        }
    ],
    "maxItems": 20,
    "sort": "PUBLISHED_DESC",
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/finn-no-jobs-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 = {
    "query": "sykepleier",
    "startUrls": [{ "url": "https://www.finn.no/job/search?q=sykepleier&sort=PUBLISHED_DESC" }],
    "maxItems": 20,
    "sort": "PUBLISHED_DESC",
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/finn-no-jobs-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 '{
  "query": "sykepleier",
  "startUrls": [
    {
      "url": "https://www.finn.no/job/search?q=sykepleier&sort=PUBLISHED_DESC"
    }
  ],
  "maxItems": 20,
  "sort": "PUBLISHED_DESC",
  "includeDetails": true
}' |
apify call automation-lab/finn-no-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINN.no Jobs Scraper",
        "description": "Scrape public FINN.no job listings with titles, companies, locations, deadlines, salaries, descriptions, and URLs.",
        "version": "0.1",
        "x-build-id": "6S5vhuVDl9vxahrfa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~finn-no-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-finn-no-jobs-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~finn-no-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-finn-no-jobs-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~finn-no-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-finn-no-jobs-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": {
                    "query": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional FINN job search keyword, for example `sykepleier`, `developer`, or `marketing`."
                    },
                    "startUrls": {
                        "title": "FINN.no job search URLs",
                        "type": "array",
                        "description": "Optional direct FINN.no `/job/search` URLs with filters. If provided, these are used instead of the keyword search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum job listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "PUBLISHED_DESC",
                            "RELEVANCE"
                        ],
                        "type": "string",
                        "description": "FINN.no sort order for keyword searches.",
                        "default": "PUBLISHED_DESC"
                    },
                    "includeDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Fetch each job ad page to include description, salary, application deadline, sector, industry, occupation, languages, and keywords. Slower but richer.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```