# Finland Digitraffic Marine AIS Scraper (`parseforge/finland-digitraffic-marine-ais-scraper`) Actor

Track live Baltic Sea vessel movements from Fintraffic Digitraffic. Pull MMSI, latitude, longitude, speed over ground, course, heading, and navigational status, with optional vessel name, ship type, and destination. Handy for maritime traffic analysis, fleet monitoring, and research.

- **URL**: https://apify.com/parseforge/finland-digitraffic-marine-ais-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🚢 Finland Digitraffic Marine AIS Scraper

> 🚀 **Track live Baltic Sea shipping in seconds.** One run returns thousands of live vessel positions straight from Fintraffic's official open marine data feed.

> 🕒 **Last updated:** 2026-06-05 · **📊 19 fields** per record · live AIS feed · Baltic Sea coverage

Fintraffic Digitraffic publishes the real Automatic Identification System (AIS) signal that ships broadcast across the Baltic. This Actor reads that open feed and turns each vessel into one clean, flat record: where it is, how fast it is going, which way it is pointing, and (optionally) its name, ship type, and stated destination.

The live `locations` endpoint typically reports well over 18,000 vessels at any moment, so even a small run gives you a rich snapshot of Gulf of Finland, Gulf of Bothnia, and open Baltic traffic. Vessel identity fields are joined on demand from the Digitraffic `vessels` metadata endpoint, keyed by MMSI.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Maritime analysts and logistics teams | Tracking vessel movements and port approaches |
| Researchers and data scientists | Studying traffic density and shipping patterns |
| Insurance and risk teams | Monitoring fleets and flagged vessels |
| Hobbyists and ship spotters | Watching named vessels move in near real time |

### 📋 What the Finland Digitraffic Marine AIS Scraper does

- Reads the live AIS `locations` GeoJSON feed from Fintraffic Digitraffic.
- Flattens every vessel feature into MMSI, latitude, longitude, speed, course, heading, navigational status, and rate of turn.
- Optionally joins vessel name, ship type, destination, call sign, and IMO number from the metadata endpoint.
- Filters results by a list of MMSI numbers or by a latitude / longitude bounding box.
- Decodes raw AIS codes into readable labels (navigational status and ship type category).

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | How many vessel records to return. Free plan is capped at 10. |
| `mmsiFilter` | array | Optional list of MMSI numbers. Only matching vessels are returned. |
| `minLat` / `maxLat` | number | Optional latitude bounds of a bounding box (WGS84). |
| `minLon` / `maxLon` | number | Optional longitude bounds of a bounding box (WGS84). |
| `includeMetadata` | boolean | Join vessel name, ship type, and destination. Default true. |

Example 1. A live snapshot of any vessels with names and destinations.

```json
{
    "maxItems": 50,
    "includeMetadata": true
}
````

Example 2. Only vessels inside a Gulf of Finland bounding box.

```json
{
    "maxItems": 100,
    "minLat": 59.0,
    "maxLat": 60.5,
    "minLon": 22.0,
    "maxLon": 28.0,
    "includeMetadata": true
}
```

> ⚠️ **Good to Know:** AIS is broadcast by the ships themselves, so optional identity fields such as `destination` are operator entered and can read `UNKNOWN`. The `positionTimestamp` reflects when each vessel last transmitted, which is why some values can be older than the moment you run the Actor.

### 📊 Output

| Field | Description |
|---|---|
| 🚢 `name` | Vessel name from metadata, when available |
| 🆔 `mmsi` | Maritime Mobile Service Identity number |
| 📍 `latitude` | Latitude in decimal degrees (WGS84) |
| 📍 `longitude` | Longitude in decimal degrees (WGS84) |
| 💨 `speedKnots` | Speed over ground in knots |
| 🧭 `courseDegrees` | Course over ground in degrees |
| ↗ `headingDegrees` | True heading in degrees |
| 🚦 `navigationalStatus` | Readable navigational status label |
| 🔢 `navStatCode` | Raw AIS navigational status code |
| 🔄 `rateOfTurn` | Rate of turn indicator |
| 🎯 `positionAccurate` | Whether the position fix is flagged as accurate |
| ⚓ `shipType` | Ship type category, decoded from the AIS code |
| 🔢 `shipTypeCode` | Raw AIS ship type code |
| 🎯 `destination` | Operator entered destination |
| 📻 `callSign` | Radio call sign |
| 🛳️ `imo` | IMO ship identification number |
| 🕒 `positionTimestamp` | When the vessel last transmitted its position |
| 🕒 `scrapedAt` | When this record was collected |
| ❌ `error` | Error message, or null on success |

Sample records from a live run:

```json
{
    "name": "NORD SUPERIOR",
    "mmsi": 219598000,
    "latitude": 55.770832,
    "longitude": 20.85169,
    "speedKnots": 0.1,
    "courseDegrees": 346.5,
    "headingDegrees": 79,
    "navigationalStatus": "At anchor",
    "navStatCode": 1,
    "rateOfTurn": 4,
    "positionAccurate": true,
    "shipType": "Tanker",
    "shipTypeCode": 80,
    "destination": "NL AMS",
    "callSign": "OWPA2",
    "imo": 9692129,
    "positionTimestamp": "2022-07-30T20:28:58.646Z",
    "scrapedAt": "2026-06-05T17:02:14.565Z",
    "error": null
}
```

```json
{
    "name": "FFS ATLAS",
    "mmsi": 376128000,
    "latitude": 59.1802,
    "longitude": 19.612433,
    "speedKnots": 6.5,
    "courseDegrees": 205.7,
    "headingDegrees": 205,
    "navigationalStatus": "Restricted manoeuvrability",
    "navStatCode": 3,
    "rateOfTurn": 0,
    "positionAccurate": true,
    "shipType": "Tug",
    "shipTypeCode": 52,
    "destination": "UNKNOWN",
    "callSign": "J8B4709",
    "imo": 8500953,
    "positionTimestamp": "2021-12-08T05:18:31.289Z",
    "scrapedAt": "2026-06-05T17:02:14.577Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Built directly on Fintraffic's official open data, no scraping of a rendered page.
- Decodes cryptic AIS numbers into labels a human can read.
- Optional metadata join means you choose between raw speed and full vessel detail.
- Bounding box and MMSI filters let you zoom into a port, a strait, or a single ship.

### 📈 How it compares to alternatives

| Approach | Identity join | Readable status | Geographic filter |
|---|---|---|---|
| This Actor | Yes, optional | Yes | Bounding box and MMSI |
| Raw API call | No | No, raw codes only | None built in |
| Commercial AIS portals | Yes | Yes | Yes, but paywalled |

### 🚀 How to use

1. Sign up for a free Apify account using our [referral link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Finland Digitraffic Marine AIS Scraper.
3. Set `maxItems`, and optionally add an MMSI list or a bounding box.
4. Click Start and watch live vessel records fill the dataset.
5. Connect the dataset to your dashboard, notebook, or downstream app.

### 💼 Business use cases

**Logistics and shipping**

| Need | How this helps |
|---|---|
| Port approach monitoring | Box filter around a harbour to see inbound traffic |
| Schedule validation | Match named vessels against expected arrivals |

**Insurance and risk**

| Need | How this helps |
|---|---|
| Fleet monitoring | MMSI list tracks a known set of vessels |
| Exposure mapping | Speed and status reveal stationary or distressed ships |

**Research and academia**

| Need | How this helps |
|---|---|
| Traffic density studies | Snapshots feed spatial analysis of the Baltic |
| Behaviour analysis | Course, heading, and rate of turn describe manoeuvres |

**Market and energy**

| Need | How this helps |
|---|---|
| Tanker watching | Ship type filter isolates tankers and their movements |
| Commodity flow signals | Destination hints at trade routing |

### 🔌 Automating Finland Digitraffic Marine AIS Scraper

Connect runs and datasets to Make, Zapier, Slack, Airbyte, GitHub, and Google Drive through Apify integrations and webhooks. Schedule the Actor to refresh a live traffic snapshot on any interval you choose, then route new records straight into your tools.

### 🌟 Beyond business use cases

- **Research:** model shipping behaviour and seasonal Baltic traffic patterns.
- **Personal:** follow a favourite ferry or cargo ship as it crosses the sea.
- **Non-profit:** support environmental and maritime safety projects with open position data.
- **Experimentation:** prototype a live map or a vessel alerting bot.

### 🤖 Ask an AI assistant

Drop a few output records into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or Microsoft Copilot and ask it to summarise traffic, cluster vessels by type, or flag ships that are stopped where they should be moving.

### ❓ Frequently Asked Questions

**Where does the data come from?**
The Fintraffic Digitraffic open marine AIS service, which republishes signals broadcast by ships.

**Is it really live?**
Yes. The `locations` endpoint returns the current AIS snapshot. Each record carries the moment that vessel last transmitted.

**Why is `destination` sometimes UNKNOWN?**
Destination is typed in by the crew, so it is often blank or a placeholder.

**Do I need an API key?**
No. The Digitraffic service is keyless. The Actor sends the courteous identifying header the service requests.

**How many vessels are available?**
The live feed routinely lists more than 18,000 vessels across the Baltic.

**Can I track one specific ship?**
Yes. Put its MMSI in the `mmsiFilter` list.

**Can I limit results to one area?**
Yes. Provide a latitude and longitude bounding box.

**What does `navigationalStatus` mean?**
It is the AIS status the ship reports, such as Under way using engine, At anchor, or Moored, decoded into words.

**Why are some position timestamps old?**
A vessel only updates when it transmits. Anchored or distant ships report less often.

**Can I turn off the metadata join?**
Yes. Set `includeMetadata` to false for faster position only runs.

### 🔌 Integrate with any app

Every run writes to an Apify dataset you can pull through the API, webhooks, or any of the platform integrations, so the data flows into spreadsheets, databases, BI tools, and custom apps.

### 🔗 Recommended Actors

- [ParseForge OurAirports Global Airport Database Scraper](https://apify.com/parseforge)
- [ParseForge Open Data Transit Scrapers](https://apify.com/parseforge)
- [ParseForge Public API Collectors](https://apify.com/parseforge)
- [ParseForge Geospatial Data Tools](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Fintraffic or Digitraffic. Only publicly available open data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `mmsiFilter` (type: `array`):

Optional. Only return vessels whose MMSI is in this list. Leave empty to return all vessels in the requested area.

## `minLat` (type: `number`):

Optional. Southern edge of the bounding box (decimal degrees, WGS84). Vessels south of this latitude are excluded.

## `maxLat` (type: `number`):

Optional. Northern edge of the bounding box (decimal degrees, WGS84). Vessels north of this latitude are excluded.

## `minLon` (type: `number`):

Optional. Western edge of the bounding box (decimal degrees, WGS84). Vessels west of this longitude are excluded.

## `maxLon` (type: `number`):

Optional. Eastern edge of the bounding box (decimal degrees, WGS84). Vessels east of this longitude are excluded.

## `includeMetadata` (type: `boolean`):

When enabled, joins vessel name, ship type, destination, call sign, and IMO number from the Digitraffic vessel metadata endpoint.

## Actor input object example

```json
{
  "maxItems": 10,
  "mmsiFilter": [],
  "includeMetadata": true
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10,
    "mmsiFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/finland-digitraffic-marine-ais-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 = {
    "maxItems": 10,
    "mmsiFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/finland-digitraffic-marine-ais-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 '{
  "maxItems": 10,
  "mmsiFilter": []
}' |
apify call parseforge/finland-digitraffic-marine-ais-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/finland-digitraffic-marine-ais-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Finland Digitraffic Marine AIS Scraper",
        "description": "Track live Baltic Sea vessel movements from Fintraffic Digitraffic. Pull MMSI, latitude, longitude, speed over ground, course, heading, and navigational status, with optional vessel name, ship type, and destination. Handy for maritime traffic analysis, fleet monitoring, and research.",
        "version": "0.1",
        "x-build-id": "EbdzeTE0crUqCcte7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~finland-digitraffic-marine-ais-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-finland-digitraffic-marine-ais-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/parseforge~finland-digitraffic-marine-ais-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-finland-digitraffic-marine-ais-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/parseforge~finland-digitraffic-marine-ais-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-finland-digitraffic-marine-ais-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mmsiFilter": {
                        "title": "MMSI Filter",
                        "type": "array",
                        "description": "Optional. Only return vessels whose MMSI is in this list. Leave empty to return all vessels in the requested area.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minLat": {
                        "title": "Min Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Optional. Southern edge of the bounding box (decimal degrees, WGS84). Vessels south of this latitude are excluded."
                    },
                    "maxLat": {
                        "title": "Max Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Optional. Northern edge of the bounding box (decimal degrees, WGS84). Vessels north of this latitude are excluded."
                    },
                    "minLon": {
                        "title": "Min Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Optional. Western edge of the bounding box (decimal degrees, WGS84). Vessels west of this longitude are excluded."
                    },
                    "maxLon": {
                        "title": "Max Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Optional. Eastern edge of the bounding box (decimal degrees, WGS84). Vessels east of this longitude are excluded."
                    },
                    "includeMetadata": {
                        "title": "Include Vessel Metadata",
                        "type": "boolean",
                        "description": "When enabled, joins vessel name, ship type, destination, call sign, and IMO number from the Digitraffic vessel metadata endpoint.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
