# FINN.no Mobility Scraper (`automation-lab/finn-no-mobility-scraper`) Actor

🚗 Extract public FINN.no vehicle listings with prices, mileage, make/model, seller signals, images, and specs for market analysis.

- **URL**: https://apify.com/automation-lab/finn-no-mobility-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

from $0.12 / 1,000 item 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 Mobility Scraper 🚗

Extract public car and mobility listings from FINN.no into clean, export-ready datasets.

FINN.no Mobility Scraper helps dealers, analysts, buyers, and marketplace teams monitor the Norwegian vehicle market without copying listings by hand.

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

FINN.no Mobility Scraper reads public FINN.no mobility search pages and saves one structured row per vehicle listing.

It starts from FINN.no search URLs you provide, follows pagination, and can open detail pages to collect richer vehicle information.

Typical data includes listing URL, FINN item ID, title, make, model, price, mileage, fuel type, gearbox, location, seller signals, images, and scrape timestamp.

### Who is it for?

#### Vehicle dealers

Track competing inventory, asking prices, mileage bands, and listing turnover in Norway.

#### Used-car buyers

Export filtered searches and compare candidate vehicles in spreadsheets or BI tools.

#### Pricing analysts

Build market snapshots for model years, mileage ranges, fuels, and brands.

#### Lead-generation teams

Collect public vehicle listing URLs and seller/contact availability signals for compliant outreach workflows.

#### Mobility market researchers

Monitor Norwegian supply across brands, categories, and search filters over time.

### Why use this scraper?

- 🚗 Designed for FINN.no mobility and car search pages.
- 📄 Uses public server-rendered HTML and JSON-LD.
- 🔎 Optional detail-page enrichment for vehicle specs.
- 💰 Pay per saved listing, so small monitoring jobs stay inexpensive.
- 📊 Exports to JSON, CSV, Excel, Google Sheets, databases, and APIs through Apify.

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

The actor uses pay-per-event pricing.

You pay a small run-start event plus a per-listing event for every saved vehicle row.

The final run cost depends on `maxItems` and whether detail pages are opened.

Use a small `maxItems` value for the first run, then scale after you confirm the search URL returns the listings you need.

### Data you can extract

| Field | Description |
|---|---|
| `listingId` | FINN.no item ID |
| `listingUrl` | Public vehicle detail page |
| `title` | Listing title |
| `make` | Vehicle brand |
| `model` | Vehicle model |
| `variant` | Model family or variant when available |
| `year` | Model year |
| `priceNok` | Price in Norwegian kroner |
| `mileageKm` | Mileage in kilometers |
| `fuel` | Fuel type |
| `gearbox` | Transmission type |
| `location` | Public listing location |
| `sellerName` | Public seller name when exposed |
| `sellerType` | Person or organization signal from structured data |
| `contactPhoneAvailable` | Whether the page contains public phone/contact signals |
| `imageUrls` | Public FINN CDN image URLs |
| `sourceSearchUrl` | Search URL where the listing was found |
| `scrapedAt` | ISO timestamp |

### Input options

#### FINN.no mobility search URLs

Paste one or more FINN.no mobility search URLs.

The default example is:

```text
https://www.finn.no/mobility/search/car?sort=RELEVANCE
````

You can apply filters on FINN.no first, then copy the resulting URL into the actor.

#### Maximum listings

`maxItems` controls the total number of listings saved across all start URLs.

Use 50 for a quick market sample.

Use 100 or more for monitoring and pricing snapshots.

#### Open listing detail pages

`includeDetails` controls whether the actor opens every listing page.

Turn it on for mileage, fuel, gearbox, model year, seller type, and image enrichment.

Turn it off for faster URL/title/price discovery from search pages only.

#### Delay between requests

`requestDelayMillis` keeps requests polite.

The default is 250 ms.

Increase it for large scheduled monitoring jobs.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.finn.no/mobility/search/car?sort=RELEVANCE" }
  ],
  "maxItems": 50,
  "includeDetails": true,
  "requestDelayMillis": 250
}
```

### Example output

```json
{
  "listingId": "465448532",
  "listingUrl": "https://www.finn.no/mobility/item/465448532",
  "title": "Mercedes-Benz C200",
  "make": "Mercedes-Benz",
  "model": "C200",
  "variant": "C-Klasse",
  "year": 2010,
  "priceNok": 76900,
  "priceCurrency": "NOK",
  "mileageKm": 184000,
  "fuel": "Diesel",
  "gearbox": "Automat",
  "location": "Rakkestad",
  "sellerType": "Person",
  "contactPhoneAvailable": true,
  "imageUrls": ["https://images.finncdn.no/dynamic/default/item/465448532/..."],
  "sourceSearchUrl": "https://www.finn.no/mobility/search/car?sort=RELEVANCE",
  "scrapedAt": "2026-07-04T03:04:07.415Z"
}
```

### How to scrape FINN.no car search results

1. Open FINN.no.
2. Go to the car or mobility search page.
3. Apply brand, model, year, price, location, or fuel filters.
4. Copy the filtered search URL.
5. Paste it into `startUrls`.
6. Set `maxItems`.
7. Keep `includeDetails` enabled for full vehicle specs.
8. Run the actor.
9. Download the dataset as CSV, JSON, Excel, or via API.

### Tips for better results

- Use filtered search URLs for targeted exports.
- Use separate runs for different brands or regions.
- Keep detail extraction enabled for data quality.
- Schedule runs daily or weekly to monitor price changes.
- Start small before scaling to thousands of listings.

### Integrations

#### Google Sheets

Send the dataset to Google Sheets for buyer shortlists, market reports, and price comparison dashboards.

#### Databases

Export JSON or CSV into PostgreSQL, BigQuery, Snowflake, or your internal warehouse.

#### CRM tools

Use public listing URLs and contact availability signals as inputs to compliant lead qualification workflows.

#### BI dashboards

Build price, mileage, year, make, and fuel visualizations in Looker, Power BI, Tableau, or Metabase.

### 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/finn-no-mobility-scraper').call({
  startUrls: [{ url: 'https://www.finn.no/mobility/search/car?sort=RELEVANCE' }],
  maxItems: 50,
  includeDetails: true
});

console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/finn-no-mobility-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.finn.no/mobility/search/car?sort=RELEVANCE'}],
    'maxItems': 50,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~finn-no-mobility-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.finn.no/mobility/search/car?sort=RELEVANCE"}],"maxItems":50,"includeDetails":true}'
```

### MCP usage

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

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 100 FINN.no car listings from this filtered search URL and summarize median price by make."
- "Export FINN.no diesel automatic listings into a CSV for my pricing analysis."
- "Monitor this FINN.no mobility search weekly and tell me when new Mercedes-Benz listings appear."

### Scheduling

You can schedule the actor on Apify to run daily, weekly, or monthly.

Scheduled runs are useful for market monitoring, price tracking, and stock comparisons.

### Data quality notes

FINN.no exposes some fields in structured JSON-LD and some fields in visible detail-page HTML.

Not every listing contains every field.

Older listings, private sellers, and different mobility categories may expose fewer details.

### Limitations

The actor extracts public listing data only.

It does not log in.

It does not bypass private messages, hidden contact details, or account-only features.

It currently defaults to car search workflows, although related mobility search URLs may work when FINN.no uses the same page structure.

### Legality

This actor extracts publicly available web data.

You are responsible for using the results in a lawful way and respecting FINN.no terms, privacy rights, and applicable regulations.

Avoid collecting or using personal data unless you have a valid legal basis.

### Troubleshooting

#### My run returns fewer listings than expected

Check whether your FINN.no search URL has strict filters or whether `maxItems` is low.

Try opening the URL in a browser and confirming it has enough public results.

#### Some fields are empty

Some fields appear only on detail pages. Keep `includeDetails` enabled.

Some listings simply do not publish every field.

#### The run is slower than expected

Detail-page enrichment requires one request per listing.

Turn `includeDetails` off for faster search-page-only discovery.

### Related scrapers

- https://apify.com/automation-lab/finn-no-jobs-scraper
- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### FAQ

#### Can I scrape filtered FINN.no searches?

Yes. Apply filters on FINN.no, copy the resulting URL, and paste it into `startUrls`.

#### Does it scrape phone numbers?

The actor records whether public phone/contact signals are visible. It does not bypass hidden contact flows.

#### Can it monitor new listings?

Yes. Schedule recurring runs and compare `listingId` values across datasets.

#### Does it need a proxy?

No proxy is configured by default. FINN.no public pages worked with ordinary HTTP requests during development.

#### Can I export the data?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, or accessed via API.

#### Can I use it for other FINN.no mobility categories?

The default workflow is cars. Similar mobility search pages may work if they expose the same listing and detail structure.

# Actor input Schema

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

One or more FINN.no mobility search URLs, for example car search pages with filters already applied.

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

Maximum number of vehicle listings to save across all start URLs.

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

Fetch each vehicle detail page to enrich search results with mileage, fuel, gearbox, model year, images, seller type, and more.

## `requestDelayMillis` (type: `integer`):

Small delay between FINN.no requests. Increase this for large monitoring jobs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.finn.no/mobility/search/car?sort=RELEVANCE"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "requestDelayMillis": 250
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.finn.no/mobility/search/car?sort=RELEVANCE"
        }
    ],
    "maxItems": 20,
    "includeDetails": true,
    "requestDelayMillis": 250
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FINN.no Mobility Scraper",
        "description": "🚗 Extract public FINN.no vehicle listings with prices, mileage, make/model, seller signals, images, and specs for market analysis.",
        "version": "0.1",
        "x-build-id": "L9KLlLuZDhFjt9vcc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~finn-no-mobility-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-finn-no-mobility-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-mobility-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-finn-no-mobility-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-mobility-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-finn-no-mobility-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": {
                    "startUrls": {
                        "title": "FINN.no mobility search URLs",
                        "type": "array",
                        "description": "One or more FINN.no mobility search URLs, for example car search pages with filters already applied.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to save across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open listing detail pages",
                        "type": "boolean",
                        "description": "Fetch each vehicle detail page to enrich search results with mileage, fuel, gearbox, model year, images, seller type, and more.",
                        "default": true
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Small delay between FINN.no requests. Increase this for large monitoring jobs.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```