# German Tender Monitor (`sgforce/german-tender-monitor`) Actor

Monitor German public tenders by keyword, CPV, region, and freshness. Export clean procurement rows for sales, research, API, CSV, and agent workflows.

- **URL**: https://apify.com/sgforce/german-tender-monitor.md
- **Developed by:** [Francesco Scilipoti](https://apify.com/sgforce) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 tender rows

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

## German Tender Monitor

German Tender Monitor helps you find relevant German public tenders without checking procurement portals by hand every day.

Give it a keyword, CPV code, region, publication date, or minimum value. It returns structured tender rows that work well in Apify datasets, CSV exports, spreadsheets, CRM workflows, dashboards, and API pipelines.

This is not meant to replace a full procurement suite. It is a lightweight monitoring layer for teams that want a clean German tender feed they can run once, schedule daily, or connect to their own tools.

Common searches this Actor is built for:

- German public tender API
- public procurement data Germany
- German procurement feed
- tender monitoring Germany
- CPV tender monitor
- Ausschreibungen API
- public sector buying signals

### What You Can Do With It

- Find software, IT, construction, cleaning, consulting, marketing, engineering, or other public tenders by keyword.
- Track categories with CPV prefixes, for example `45` for construction or `72` for IT services.
- Monitor a region, city, postcode, or German NUTS-style region code.
- Run a small one-off research export.
- Schedule a recurring monitor and return only tender rows that were not seen before.
- Export the result as JSON or CSV for follow-up work.

### Good First Run

Start small:

```json
{
  "maxItems": 20
}
````

If you do not set a publication day or month, the Actor looks for the latest useful daily export in a short lookback window. This makes first tests and scheduled runs less brittle around weekends and holidays.

### Example: Software And IT Tenders

```json
{
  "maxItems": 20,
  "keyword": "software"
}
```

Typical fields to inspect:

- `title`
- `buyer`
- `buyerDomain`
- `cpv`
- `cpvLabel`
- `publicationDate`
- `deadlineStatus`
- `leadReason`
- `detailUrl`

Real sample from a live run:

```text
Hard- und Softwarewartung für Fortinet-Produkte
Buyer: Emschergenossenschaft
CPV: 72000000
CPV label: IT services: consulting, software development, Internet and support
```

### Example: Construction Tenders By CPV

```json
{
  "maxItems": 20,
  "cpv": "45"
}
```

CPV `45` covers construction work. The Actor adds `cpvLabel`, so downstream users do not need to memorize CPV divisions.

Real sample from a live run:

```text
Neubau eines Busbetriebshofes
Buyer: Freisinger Stadtwerke Versorgungs-GmbH
Estimated value: 1102545 EUR
Lead reason: Matched CPV 45; estimated value 1102545 EUR; Construction work
```

### Example: Regional Tender Monitoring

```json
{
  "maxItems": 20,
  "region": "DE6"
}
```

Use `region` for city names, postcodes, German region codes, or country subdivisions.

Real sample from a live Hamburg run:

```text
Eißendorfer Straße 26 - Abbuch
Buyer: GMH | Gebäudemanagement Hamburg GmbH
City: Hamburg
Region: DE600
Estimated value: 8641000 EUR
```

### Example: Daily New-Only Feed

```json
{
  "maxItems": 20,
  "keyword": "software",
  "newOnly": true,
  "stateKey": "software-daily"
}
```

The first run creates the baseline. Later runs with the same `stateKey` return only tender rows that were not seen before.

Use different state keys for different monitors:

- `software-daily`
- `hamburg-construction`
- `cleaning-weekly`
- `consulting-north-germany`

### Input Fields

- `pubDay`: publication day in `YYYY-MM-DD`.
- `pubMonth`: publication month in `YYYY-MM`. Use this for broader research.
- `maxItems`: maximum number of rows returned.
- `keyword`: search across title, buyer, description, CPV, city, and region.
- `cpv`: CPV prefix, for example `45` or `72`.
- `region`: city, postcode, region, subdivision, or country code.
- `minEstimatedValue`: return rows above this value when a value is available.
- `includeAwardNotices`: include award/change/result notices.
- `fallbackDays`: look back this many publication days when no date/month is set.
- `newOnly`: return only rows not seen before for the selected monitor.
- `stateKey`: stable key for the `newOnly` state.
- `resetSeen`: clear stored seen state before this run.

### Output Fields

Tender and buyer:

- `title`
- `buyer`
- `buyerIdentifier`
- `buyerWebsite`
- `buyerDomain`
- `buyerProfileUrl`
- `buyerLegalType`
- `description`
- `detailUrl`

Location and category:

- `city`
- `postalCode`
- `region`
- `country`
- `cpv`
- `cpvLabel`
- `cpvDivision`
- `additionalCpvs`
- `additionalCpvLabels`

Dates, value, and source context:

- `estimatedValue`
- `currency`
- `publicationDate`
- `sourceAgeDays`
- `sourceFreshness`
- `deadlineDate`
- `deadlineType`
- `deadlineStatus`
- `contractStartDate`
- `contractEndDate`

Workflow fields:

- `matchedKeyword`
- `matchedCpv`
- `matchedRegion`
- `leadReason`
- `rankScore`

Source and dedupe fields:

- `source`
- `sourceId`
- `sourceNoticeId`
- `sourceExportUrl`
- `sourcePriority`
- `canonicalFingerprint`
- `duplicateOf`
- `duplicateConfidence`
- `detectedAt`

### SUMMARY And Source Health

Each run also writes a `SUMMARY` record to the key-value store.

Check it when a run is empty or looks suspicious. It includes the normalized input, selected export, fallback attempts, source row counts, matched row counts, and `sourceHealth`.

`sourceHealth` tells you:

- whether the public data export was reachable
- how many fallback attempts were used
- how many source notice rows were found
- how many rows matched your filters
- what to try next if the result is empty

For `newOnly` runs, the summary also includes the monitoring key, previous seen count, matched item count, newly emitted item count, and total seen count.

### Pricing

This Actor uses Apify Pay per event.

- Main event: `Tender row`
- Technical event: `apify-default-dataset-item`
- Price: `$0.0015` per dataset row
- Simple estimate: `$1.50 / 1,000 tender rows`

Examples:

- 20 rows: about `$0.03`
- 100 rows: about `$0.15`
- 1,000 rows: about `$1.50`

Apify may also charge normal platform usage depending on your account and run settings. Keep `maxItems` low for the first test.

### API And Automation

You can run the Actor from the Apify Console, Apify API, SDKs, schedules, webhooks, or automation tools.

Basic API call:

```bash
curl -X POST "https://api.apify.com/v2/acts/sgforce~german-tender-monitor/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "maxItems": 20,
    "keyword": "software",
    "newOnly": true,
    "stateKey": "software-daily"
  }'
```

This makes the Actor useful as a small German public procurement data API, not just as a manual export tool.

### Official Sources And Limits

The Actor builds one normalized tender feed from publicly accessible official procurement sources. Depending on the selected date window and filters, these include sources such as:

- German public procurement bulk exports
- TED Search API for Germany-related EU notices
- selected regional Open Data ZIP feeds, including NRW procurement feeds

This source mix is not limited to one search page or one portal view. Rows are normalized and deduplicated across available official/public data sources with stable source IDs, canonical fingerprints, source priority, and normalized tender/buyer/category fields.

Limits to know:

- This is not complete coverage of every German procurement portal or every possible official source.
- TED is used through the official Search API. The Actor uses the API result fields for broad stable coverage and does not mass-download TED XML in normal runs.
- TED notices are capped per run for stability. Use `pubDay`, `pubMonth`, `cpv`, `keyword`, and `maxItems` to keep runs targeted.
- Some notices do not include estimated value, buyer website, detailed deadline, or complete location fields.
- Deadline fields are conservative. If no reliable date is available, `deadlineStatus` is `missing` instead of guessed.
- Publication-day exports are usually useful after official processing, generally the following day.
- The Actor does not submit bids, download restricted files, log into procurement portals, or provide legal/procurement advice.

### Who This Is For

Good fit:

- B2B sales teams watching public-sector demand
- IT, construction, cleaning, consulting, marketing, or engineering suppliers
- agencies and consultants doing market research
- teams that want a CSV/API feed instead of manual portal checks
- data builders and agents that need structured German tender rows

Bad fit:

- teams that need a full bid-management system
- users who expect complete national coverage across every German portal
- workflows that require restricted tender documents or bid submission
- legal or procurement-advice use cases

### FAQ

#### Is this a German tender API?

It can be used that way. The Actor runs on Apify and returns structured JSON/CSV rows for German public tenders. You can call it through the Apify API, SDKs, schedules, or webhooks.

#### Can I monitor tenders by CPV code?

Yes. Use the `cpv` input with a prefix such as `45` for construction or `72` for IT services.

#### Can I monitor only new tenders?

Yes. Use `newOnly: true` with a stable `stateKey`. The first run creates the baseline; later runs emit only unseen rows.

#### Is this complete coverage of all German tenders?

No. It is a focused monitoring feed across several public data sources. Germany has multiple procurement portals, so do not treat this as complete national coverage.

#### Why are some fields empty?

The Actor preserves what the public data provides. Some notices do not include estimated values, buyer websites, detailed deadlines, or full locations.

#### Does it scrape portal pages?

It does not automate a visual search page. It reads public bulk export data and turns the tables into joined tender rows.

#### Does it submit bids or contact buyers?

No. It only returns structured tender notice data.

#### Can AI agents use it?

Yes, if they can call Apify Actors or consume Apify datasets. The output is predictable JSON with fields such as `title`, `buyer`, `cpvLabel`, `buyerDomain`, `deadlineStatus`, and `leadReason`.

### Demo And Validation Samples

Reusable guide:

- `docs/how-to-monitor-german-public-tenders-with-apify.md`

Validation samples:

- `docs/validation/software-sample-output.json`
- `docs/validation/construction-sample-output.json`
- `docs/validation/hamburg-sample-output.json`

These include real software, construction, and Hamburg-region runs.

### Support

If a run looks wrong, open the run's `SUMMARY` record first.

For support, include:

- Actor run ID
- input JSON
- `SUMMARY` content
- one example tender row if the issue is about a field
- what you expected to see

Please do not send private procurement portal credentials. This Actor is designed around public and officially accessible procurement data sources.

### Changelog

- `0.1.16`: Added source balancing for broad multi-source runs so large default/monthly exports include visible OEV, TED, and NRW coverage instead of letting one source dominate the first returned rows.
- `0.1.15`: Added multi-source default coverage with German procurement bulk data, TED Search API Germany notices, and selected NRW Open Data feeds. Added cross-source deduplication with source IDs, source priority, canonical fingerprints, and title/buyer/CPV/location matching.
- `0.1.7`: Added `sourceHealth` to the run summary, including source reachability, attempted exports, source row counts, matched row counts, and empty-result status.
- `0.1.5`: Added CPV labels, additional CPV codes, buyer enrichment, deadline/opening-date status, source freshness, and lead-reason fields.
- `0.1.4`: Added `newOnly` monitoring mode with persistent seen-state keys for scheduled workflows and alerts.
- `0.1.3`: Added default lookback behavior so no-date runs search recent publication days until useful results are found.
- `0.1.1`: First deployed Apify Cloud build.

# Actor input Schema

## `pubDay` (type: `string`):

Publication day in YYYY-MM-DD. Defaults to yesterday because the official export is available after midnight.

## `pubMonth` (type: `string`):

Publication month in YYYY-MM. Cannot be combined with pubDay.

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

Maximum tender rows returned. Keep this low for first tests and raise it for scheduled monitoring or market research.

## `keyword` (type: `string`):

Optional case-insensitive keyword filter across title, buyer, description, CPV, city, and region.

## `cpv` (type: `string`):

Optional CPV prefix, e.g. 45 for construction or 72 for IT services.

## `region` (type: `string`):

Optional filter for city, postcode, subdivision, or country code.

## `minEstimatedValue` (type: `integer`):

Only return rows with at least this estimated value when a value is available.

## `includeAwardNotices` (type: `boolean`):

Include award/change/result notices. Default keeps tender-like opportunity notices only.

## `fallbackDays` (type: `integer`):

When no pubDay or pubMonth is set, search this many previous publication days until a non-empty result is found. This makes default test runs robust around weekends and public holidays.

## `newOnly` (type: `boolean`):

Return only tender rows that have not been seen before for this monitoring state. Useful for scheduled daily runs and alert workflows.

## `stateKey` (type: `string`):

Optional stable key for newOnly state, e.g. software-daily or hamburg-construction. Use different keys for different monitors.

## `resetSeen` (type: `boolean`):

Clear the previous seen state before this run. Use this to restart a monitor or re-emit current tenders.

## Actor input object example

```json
{
  "maxItems": 20,
  "minEstimatedValue": 0,
  "includeAwardNotices": false,
  "fallbackDays": 7,
  "newOnly": false,
  "resetSeen": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sgforce/german-tender-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sgforce/german-tender-monitor").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 '{}' |
apify call sgforce/german-tender-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sgforce/german-tender-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "German Tender Monitor",
        "description": "Monitor German public tenders by keyword, CPV, region, and freshness. Export clean procurement rows for sales, research, API, CSV, and agent workflows.",
        "version": "0.1",
        "x-build-id": "UC9recgEjDZXrgMJG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sgforce~german-tender-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sgforce-german-tender-monitor",
                "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/sgforce~german-tender-monitor/runs": {
            "post": {
                "operationId": "runs-sync-sgforce-german-tender-monitor",
                "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/sgforce~german-tender-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-sgforce-german-tender-monitor",
                "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": {
                    "pubDay": {
                        "title": "Publication day",
                        "type": "string",
                        "description": "Publication day in YYYY-MM-DD. Defaults to yesterday because the official export is available after midnight."
                    },
                    "pubMonth": {
                        "title": "Publication month",
                        "type": "string",
                        "description": "Publication month in YYYY-MM. Cannot be combined with pubDay."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum tender rows returned. Keep this low for first tests and raise it for scheduled monitoring or market research.",
                        "default": 20
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Optional case-insensitive keyword filter across title, buyer, description, CPV, city, and region."
                    },
                    "cpv": {
                        "title": "CPV prefix",
                        "type": "string",
                        "description": "Optional CPV prefix, e.g. 45 for construction or 72 for IT services."
                    },
                    "region": {
                        "title": "Region/city filter",
                        "type": "string",
                        "description": "Optional filter for city, postcode, subdivision, or country code."
                    },
                    "minEstimatedValue": {
                        "title": "Minimum estimated value",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return rows with at least this estimated value when a value is available.",
                        "default": 0
                    },
                    "includeAwardNotices": {
                        "title": "Include award/change notices",
                        "type": "boolean",
                        "description": "Include award/change/result notices. Default keeps tender-like opportunity notices only.",
                        "default": false
                    },
                    "fallbackDays": {
                        "title": "Default lookback days",
                        "minimum": 0,
                        "maximum": 14,
                        "type": "integer",
                        "description": "When no pubDay or pubMonth is set, search this many previous publication days until a non-empty result is found. This makes default test runs robust around weekends and public holidays.",
                        "default": 7
                    },
                    "newOnly": {
                        "title": "Only new tenders",
                        "type": "boolean",
                        "description": "Return only tender rows that have not been seen before for this monitoring state. Useful for scheduled daily runs and alert workflows.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "Monitoring state key",
                        "type": "string",
                        "description": "Optional stable key for newOnly state, e.g. software-daily or hamburg-construction. Use different keys for different monitors."
                    },
                    "resetSeen": {
                        "title": "Reset seen tenders",
                        "type": "boolean",
                        "description": "Clear the previous seen state before this run. Use this to restart a monitor or re-emit current tenders.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
