# Arbeitsagentur Jobs Scraper - Germany (`benthepythondev/arbeitsagentur-jobs-scraper`) Actor

Scrape Germany's official Arbeitsagentur jobs API with full descriptions, employer, locations, coordinates, remote status, working time and public contacts.

- **URL**: https://apify.com/benthepythondev/arbeitsagentur-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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.

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

## Arbeitsagentur Jobs Scraper - Germany

Collect structured vacancies from Germany's official **Bundesagentur für Arbeit / Arbeitsagentur** jobs service. Search by keyword and location, apply radius, posting-age, offer-type and work-schedule filters, and optionally enrich every row with the complete public job record.

The Actor returns titles, occupations, employers, locations, coordinates, publication and entry dates, full descriptions, remote-work status, working-time flags, contract metadata, employer logos and public email or phone contacts found in the listing text. Export results to JSON, CSV, Excel or XML, schedule recurring runs, or consume the dataset through the Apify API.

### What can you use this Actor for?

- Monitor new German vacancies by role, skill, city, region or postcode.
- Build recurring feeds for recruitment, job aggregation and career services.
- Measure hiring demand across German regions and occupations.
- Track employers publishing new roles or expanding into new locations.
- Find public employer contact details disclosed in vacancy descriptions.
- Compare full-time, part-time, home-office, shift and mini-job supply.
- Research apprenticeships, internships, traineeships and dual-study openings.
- Feed spreadsheets, dashboards, databases, CRMs, Make, Zapier or n8n.

### Why use the Arbeitsagentur source?

The Bundesagentur für Arbeit operates Germany's federal employment service and exposes a broad public vacancy dataset. Compared with a small commercial job board, it covers many employers, occupations and regions, including listings that are useful for local labor-market research.

The source also provides structured detail records. Depending on the vacancy, these can include several work locations, precise coordinates, home-office availability, working-time options, contract duration, compensation status, first-publication date and a long employer-supplied description. The Actor normalizes those German fields into stable English keys while preserving the original values.

### Input

The default run searches for `Python Entwickler` within 50 kilometers of Berlin, keeps jobs from the last 14 days, fetches full details and saves up to 10 results. The bounded default is designed to complete quickly in Apify's automated quality checks.

| Field | Purpose |
|---|---|
| `keywords` | Roles, skills, occupations or employer terms to search. |
| `locations` | German cities, regions or postcodes. |
| `radiusKm` | Distance around each requested location. |
| `offerType` | Employment, self-employment, training/dual study, or internship/trainee. |
| `workSchedules` | Optional full-time, part-time, shift, home-office or mini-job filters. |
| `postedWithinDays` | Request only jobs published recently; `0` means any age. |
| `includeTemporaryAgencies` | Include or exclude temporary-work agency vacancies. |
| `includeDetails` | Fetch descriptions, all locations, remote status and public contacts. |
| `maxResultsPerSearch` | Maximum unique rows per keyword and location combination. |
| `maxPagesPerSearch` | Safety limit for source pagination. |

#### Example input

```json
{
  "keywords": ["Softwareentwickler", "Data Engineer"],
  "locations": ["Berlin", "Hamburg"],
  "radiusKm": 50,
  "offerType": "1",
  "workSchedules": ["vz", "ho"],
  "postedWithinDays": 30,
  "includeTemporaryAgencies": false,
  "includeDetails": true,
  "maxResultsPerSearch": 25
}
````

The Actor runs each keyword and location combination independently and deduplicates overlapping vacancies by the federal reference number before output.

### Output

Each dataset row represents one public vacancy. Common fields include:

- `reference`, `url`, `application_url`
- `title`, `occupation`, `description`, `offer_type`
- `employer`, `employer_logo`
- `city`, `postal_code`, `street_address`, `region`, `country`
- `latitude`, `longitude`, `distance_km`, `locations`
- `published_at`, `first_published_at`, `modified_at`, `entry_date`
- `valid_from`, `valid_until`
- `full_time`, `part_time_flexible`, `part_time_morning`
- `part_time_afternoon`, `part_time_evening`, `shift_night_weekend`
- `home_office_possible`, `home_office_type`
- `contract_duration`, `compensation`, `disability_required`
- `is_agency_managed`, `partner_name`, `partner_url`
- `contact_emails`, `contact_phones`, `lead_score`
- `source_keyword`, `source_location`, `search_rank`, `scraped_at`

#### Example result

```json
{
  "reference": "10001-1003356732-S",
  "title": "AI Lead, Python Tools (m/f/d)",
  "occupation": "Software-Architect",
  "employer": "JetBrains GmbH",
  "city": "Berlin",
  "region": "Berlin",
  "home_office_possible": true,
  "home_office_type": "NACH_VEREINBARUNG",
  "full_time": true,
  "published_at": "2026-07-09",
  "entry_date": "2026-07-09",
  "url": "https://www.arbeitsagentur.de/jobsuche/jobdetail/10001-1003356732-S"
}
```

Not every employer publishes salary, contact or remote-work information. Missing fields remain empty rather than being inferred. `compensation` often contains a source classification instead of a numeric amount; keep that distinction when analyzing results.

### Lead and contact fields

When detail enrichment is enabled, the Actor scans the employer-supplied public description for email addresses and German phone-number patterns. The values are returned in `contact_emails` and `contact_phones`. No private account, login, enrichment database or guessed address is used.

`lead_score` is a transparent completeness score. It rewards a named employer, public contact fields, a full description, location data, an employer logo, remote-work metadata and a canonical listing URL. It does not predict whether an employer will respond and should not replace human qualification.

### Reliable extraction design

Search and detail records come from the federal jobs service's public JSON endpoints. The Actor uses bounded pagination, retries temporary failures, enriches details concurrently with a strict connection limit and deduplicates by the official reference number. It does not need a browser, paid proxy or third-party API key, which keeps runs fast and operating costs low.

The run fails visibly when the source returns no usable jobs. A successful process with an empty dataset is not treated as healthy. All output rows are pushed to the default dataset, so pay-per-event billing remains transparent.

### Scheduling and integrations

For a daily hiring monitor, combine stable keywords and locations with `postedWithinDays: 1` or `7`. Store `reference` as the external primary key, then alert only when a new value appears. For labor-market analysis, group rows by `occupation`, `region`, `home_office_possible`, `full_time` or `employer`.

Use the dataset API to load results into a warehouse or application. Apify integrations can send completed datasets to webhooks, Make, Zapier, n8n or cloud storage. CSV and Excel exports work well for one-off research, while JSON is better for recurring pipelines.

### Pricing

This Actor uses pay-per-event pricing. A very small start event covers run initialization, and each unique vacancy saved to the default dataset is billed as one `result`. Duplicate jobs discarded before output are not billed as additional results.

### Responsible use

The Actor collects public vacancy and employer information. Use it for legitimate recruitment, research, aggregation and monitoring workflows. Follow applicable employment, privacy, database and marketing rules. Verify time-sensitive details on the canonical Arbeitsagentur page before applying, contacting an employer or making decisions.

### FAQ

#### Is an Arbeitsagentur account required?

No. The Actor reads public search and job-detail data without a user login.

#### Can I search multiple cities and roles?

Yes. Add several `keywords` and `locations`. Each combination is searched, and duplicate federal references are returned once.

#### Can I collect only remote-capable jobs?

Add `ho` to `workSchedules`. With detail enrichment enabled, inspect `home_office_possible` and `home_office_type` for the source's more precise remote-work metadata.

#### Why is a contact field empty?

Contacts are returned only when the employer publishes them in the vacancy description. The Actor does not guess or buy private contact data.

#### Can I search apprenticeships or internships?

Yes. Select the corresponding `offerType`: `4` for training or dual study and `34` for internship or trainee listings.

#### How do I prevent duplicates across scheduled runs?

Use `reference` as the primary key. The Actor deduplicates within a run; your destination can use the same value across runs.

#### What should I report in an issue?

Include a small input, the run URL and the expected behavior. Do not include credentials or private candidate data.

### You might also like

- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper) for commercial European job-board listings.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/benthepythondev/welcome-to-the-jungle-jobs-scraper) for European startup and employer-profile data.
- [Xing Jobs Scraper](https://apify.com/benthepythondev/xing-jobs-scraper) for German-speaking professional-market vacancies.
- [Remote Jobs Aggregator](https://apify.com/benthepythondev/remote-jobs-aggregator) for multi-source remote roles.

If this Actor saves you time, please leave a review on its Apify Store page. Reviews help prioritize reliability work and requested features.

**Keywords:** Arbeitsagentur scraper, Bundesagentur für Arbeit API, German jobs scraper, Jobbörse scraper, Germany jobs API, Arbeitsagentur jobs data, recruitment data Germany, German labor market, remote jobs Germany, Ausbildung jobs scraper, employer lead generation, Apify jobs scraper

# Actor input Schema

## `keywords` (type: `array`):

German or English roles, skills, occupations or employer terms to search.

## `locations` (type: `array`):

Cities, regions or postcodes to search in Germany.

## `radiusKm` (type: `integer`):

Maximum distance around each requested location.

## `offerType` (type: `string`):

Type of vacancy to request from the federal jobs API.

## `workSchedules` (type: `array`):

Optional working-time filters from the source API.

## `postedWithinDays` (type: `integer`):

Only request jobs published within this many days; use 0 for any age.

## `includeTemporaryAgencies` (type: `boolean`):

Include vacancies posted by temporary-work agencies in source results.

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

Enrich each result with the full description, all locations, working time, remote status and public contacts.

## `maxResultsPerSearch` (type: `integer`):

Maximum unique jobs saved for each keyword and location combination.

## `maxPagesPerSearch` (type: `integer`):

Safety cap for federal jobs API pagination.

## Actor input object example

```json
{
  "keywords": [
    "Python Entwickler",
    "Data Engineer"
  ],
  "locations": [
    "Berlin",
    "München"
  ],
  "radiusKm": 50,
  "offerType": "1",
  "workSchedules": [],
  "postedWithinDays": 14,
  "includeTemporaryAgencies": false,
  "includeDetails": true,
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 20
}
```

# 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 = {
    "keywords": [
        "Python Entwickler",
        "Data Engineer"
    ],
    "locations": [
        "Berlin",
        "München"
    ],
    "radiusKm": 50,
    "offerType": "1",
    "postedWithinDays": 14,
    "includeTemporaryAgencies": false,
    "includeDetails": true,
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/arbeitsagentur-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 = {
    "keywords": [
        "Python Entwickler",
        "Data Engineer",
    ],
    "locations": [
        "Berlin",
        "München",
    ],
    "radiusKm": 50,
    "offerType": "1",
    "postedWithinDays": 14,
    "includeTemporaryAgencies": False,
    "includeDetails": True,
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/arbeitsagentur-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 '{
  "keywords": [
    "Python Entwickler",
    "Data Engineer"
  ],
  "locations": [
    "Berlin",
    "München"
  ],
  "radiusKm": 50,
  "offerType": "1",
  "postedWithinDays": 14,
  "includeTemporaryAgencies": false,
  "includeDetails": true,
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 20
}' |
apify call benthepythondev/arbeitsagentur-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arbeitsagentur Jobs Scraper - Germany",
        "description": "Scrape Germany's official Arbeitsagentur jobs API with full descriptions, employer, locations, coordinates, remote status, working time and public contacts.",
        "version": "1.0",
        "x-build-id": "9NQjKPoIW2Mbkdjeu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~arbeitsagentur-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-arbeitsagentur-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/benthepythondev~arbeitsagentur-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-arbeitsagentur-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/benthepythondev~arbeitsagentur-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-arbeitsagentur-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",
                "required": [
                    "keywords",
                    "locations"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "German or English roles, skills, occupations or employer terms to search.",
                        "default": [
                            "Python Entwickler"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "German locations",
                        "type": "array",
                        "description": "Cities, regions or postcodes to search in Germany.",
                        "default": [
                            "Berlin"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "radiusKm": {
                        "title": "Search radius in kilometers",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum distance around each requested location.",
                        "default": 50
                    },
                    "offerType": {
                        "title": "Offer type",
                        "enum": [
                            "1",
                            "2",
                            "4",
                            "34"
                        ],
                        "type": "string",
                        "description": "Type of vacancy to request from the federal jobs API.",
                        "default": "1"
                    },
                    "workSchedules": {
                        "title": "Work schedules",
                        "type": "array",
                        "description": "Optional working-time filters from the source API.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "vz",
                                "tz",
                                "snw",
                                "ho",
                                "mj"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Shift/night/weekend",
                                "Home office",
                                "Mini-job"
                            ]
                        },
                        "default": []
                    },
                    "postedWithinDays": {
                        "title": "Maximum posting age",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only request jobs published within this many days; use 0 for any age.",
                        "default": 14
                    },
                    "includeTemporaryAgencies": {
                        "title": "Include temporary-work agencies",
                        "type": "boolean",
                        "description": "Include vacancies posted by temporary-work agencies in source results.",
                        "default": false
                    },
                    "includeDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Enrich each result with the full description, all locations, working time, remote status and public contacts.",
                        "default": true
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum jobs per keyword and location",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique jobs saved for each keyword and location combination.",
                        "default": 10
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum API pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for federal jobs API pagination.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
