# WFS Feature Extractor (`datamule/wfs-feature-extractor`) Actor

Point at ANY classic OGC WFS 2.0/1.1 service (GeoServer, MapServer, deegree, QGIS-Server) behind national & city SDIs. Reads GetCapabilities, pages GetFeature by bbox/CQL, returns flat feature rows (geometry, lon/lat, computed bbox, properties, SRS) from GeoJSON OR GML. Pay per feature.

- **URL**: https://apify.com/datamule/wfs-feature-extractor.md
- **Developed by:** [Datamule](https://apify.com/datamule) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 features

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## WFS Feature Extractor

**Point at ANY classic OGC WFS service and get clean, flat feature rows.**

This actor is a generic runner for the **classic OGC Web Feature Service (WFS)**
protocol — versions **2.0.0** and **1.1.0** (with a 1.0.0 courtesy fallback). Classic
WFS is the older, still-ubiquitous XML vector-feature standard: `GetCapabilities` →
`GetFeature`. It is **distinct from the modern JSON-native "OGC API - Features"** — if
your service exposes `/collections/{id}/items` JSON, use an OGC API Features extractor
instead; this one speaks the classic `SERVICE=WFS&REQUEST=GetFeature` XML protocol that
**tens of thousands of GeoServer, MapServer, deegree, QGIS-Server and MapProxy
deployments** (national mapping agencies, city GIS portals, INSPIRE / national SDIs)
still serve.

One actor turns any of them into structured rows — no per-site scraper.

### What it does

1. **Reads GetCapabilities** and parses the `FeatureTypeList` catalog (name, title,
   default CRS, advertised output formats).
2. **Pages GetFeature** for each requested (or every advertised) feature type, using
   `COUNT`/`STARTINDEX` paging on 2.0.0.
3. **Negotiates the wire format**: it prefers a GeoJSON format the type advertises, and
   **falls back to the server-default GML** — which it fully parses (GML 3.2 / 3.1.1 /
   2.x; Point, LineString, Polygon and Multi\* geometries) into the **same** normalized
   row shape. The GeoJSON path and the GML path yield identical coordinates.
4. **Normalizes axis order** — the classic WFS/GML trap. GeoJSON is lon/lat by spec;
   GML coordinate order depends on the CRS, so for the well-known geographic CRSs
   (EPSG:4326 and friends) the parser swaps to lon/lat and flags `geoAxisSwapped: true`,
   while CRS84 and projected CRSs (e.g. EPSG:28992) are kept verbatim. Every row records
   its declared `srs` so nothing is ambiguous.

### Modes

- **Discovery** — leave *Feature type name(s)* empty (or turn on *List feature types
  only*): the actor emits one row per advertised feature type (name, title, abstract,
  default CRS, supported output formats). A cheap map of what the service serves.
- **Extract** — set one or more *Feature type name(s)* (e.g. `ms:cities`, `bag:pand`) and
  optionally a `BBOX`, a `CQL_FILTER`, an OGC XML `Filter`, or an output `srsName`.

### Input

| Field | Description |
|-------|-------------|
| **WFS service URL** (required) | Base URL the service answers `GetCapabilities` on, e.g. `https://demo.mapserver.org/cgi-bin/wfs`. Any pre-existing query (`?map=…`) is preserved. |
| **Feature type name(s)** | One or more type names. Empty → discovery mode. |
| **List feature types only** | Discovery: list the catalog, fetch no features. |
| **WFS version** | Preferred version (`2.0.0` / `1.1.0` / `1.0.0`); auto-negotiated. |
| **Bounding box (BBOX)** | Spatial filter, e.g. `-60,-40,-50,-30,urn:ogc:def:crs:EPSG::4326`. |
| **CQL filter** | GeoServer/MapServer `CQL_FILTER`, e.g. `POPULATION > 1000000`. |
| **OGC XML filter** | Raw `<fes:Filter>` for the standards-based `FILTER` param. |
| **Output format override** | Force an `OUTPUTFORMAT` token; default auto-negotiates. |
| **Output SRS (srsName)** | Request features reprojected to a CRS, e.g. `EPSG:3857`. |
| **Max features (total)** | Cap across all pages/types. One billable event per feature. |
| **Page size** | Server-side page size per request. |
| **Extra query parameters** | Vendor-specific passthrough (JSON object). |
| **Bearer token / Extra headers** | Optional auth for gated deployments. Never logged. |

### Output

One row per feature, with a normalized shape regardless of the source wire format:

```json
{
  "_endpoint": "https://demo.mapserver.org/cgi-bin/wfs",
  "_wfsVersion": "2.0.0",
  "_outputFormat": "geojson",
  "featureType": "cities",
  "featureId": "cities.8338",
  "geometryType": "Point",
  "longitude": -58.6725,
  "latitude": -34.5875,
  "bbox": [-58.6725, -34.5875, -58.6725, -34.5875],
  "srs": "urn:ogc:def:crs:OGC:1.3:CRS84",
  "geoAxisSwapped": false,
  "propertyKeys": ["NAME", "POPULATION"],
  "propertyCount": 2,
  "geometry": { "type": "Point", "coordinates": [-58.6725, -34.5875] },
  "properties": { "POPULATION": 12116379, "NAME": "Buenos Aires" },
  "sourceUrl": "https://demo.mapserver.org/cgi-bin/wfs?SERVICE=WFS&…",
  "raw": { }
}
````

Discovery rows carry `_outputFormat: "capabilities"`, `title`, `abstract`, `defaultCrs`
and `outputFormats` instead.

### Resilience

Per-type, like a batch harvester: a feature type that errors (HTTP 4xx/5xx, a timeout,
a WFS `ExceptionReport`, or an unparseable body) is a **skip-with-warning** and the run
continues. If a GeoJSON request fails, the type is retried once as server-default GML. A
run where **every** requested type fails exits non-zero (91) so nothing broken ships. A
reachable type that genuinely has no matching features yields 0 rows and a clean exit —
the actor never fabricates rows.

### Pricing

**Pay-per-event:** one `feature` charge per emitted row.

### Example

Extract the three most-populous world cities from the OSGeo MapServer demo:

```json
{
  "wfsUrl": "https://demo.mapserver.org/cgi-bin/wfs",
  "typeNames": ["cities"],
  "cqlFilter": "POPULATION > 10000000",
  "maxFeatures": 3
}
```

# Actor input Schema

## `wfsUrl` (type: `string`):

The base URL of ANY classic OGC WFS service (the older, XML GetCapabilities → GetFeature protocol — distinct from the modern JSON 'OGC API - Features'). This is the endpoint the service answers SERVICE=WFS\&REQUEST=GetCapabilities on. Examples: https://demo.mapserver.org/cgi-bin/wfs (MapServer) or https://service.pdok.nl/lv/bag/wfs/v2\_0 (PDOK / GeoServer). Any pre-existing query (e.g. ?map=...) is preserved.

## `typeNames` (type: `array`):

Feature type(s) to pull, e.g. ms:cities, bag:pand, or a bare local name like cities. Accepts one or more. Leave EMPTY to run in discovery mode (list every feature type the service advertises). Turn on "List feature types only" below to just browse the catalog first.

## `listTypesOnly` (type: `boolean`):

When on, the actor only reads GetCapabilities and returns one row per advertised feature type (name, title, abstract, default CRS, supported output formats) — it does NOT fetch any features. Use this to discover what a service exposes, then set Feature type name(s) + a bbox/CQL filter to extract features.

## `wfsVersion` (type: `string`):

Preferred WFS protocol version. The actor negotiates automatically — if the service doesn't speak the preferred version it falls back through 2.0.0 → 1.1.0 → 1.0.0 — and the version reported on every row is the one the server actually served.

## `bbox` (type: `string`):

Optional spatial filter passed as the WFS BBOX parameter, as a comma string. WFS 2.0.0 form: minX,minY,maxX,maxY,CRS (e.g. -60,-40,-50,-30,urn:ogc:def:crs:EPSG::4326). Axis order and CRS follow the target service — check GetCapabilities. Leave empty for no spatial filter.

## `cqlFilter` (type: `string`):

Optional CQL\_FILTER expression (GeoServer / MapServer support this vendor extension), e.g. POPULATION > 1000000 or NAME = 'Manila'. Mutually exclusive with an XML Filter below — if both are set, CQL is sent. Leave empty for no attribute filter.

## `filter` (type: `string`):

Optional raw OGC Filter Encoding XML passed as the FILTER parameter (the standards-based alternative to CQL, supported by all classic WFS servers). Advanced — leave empty unless you have a specific <fes:Filter>…\</fes:Filter> to send.

## `outputFormat` (type: `string`):

Optional OUTPUTFORMAT override. By default the actor auto-negotiates: it prefers a GeoJSON format the type advertises, and falls back to the server-default GML (which it fully parses to the same row shape). Only set this to force a specific token, e.g. application/json; subtype=geojson or text/xml; subtype=gml/3.1.1. Leave empty for auto.

## `srsName` (type: `string`):

Optional SRSNAME to request features reprojected to a specific CRS, e.g. urn:ogc:def:crs:EPSG::4326 or EPSG:3857 (only honored if the type advertises that CRS). Leave empty to use the service's default CRS.

## `maxFeatures` (type: `integer`):

Maximum total number of features to pull across all pages and feature types (the actor auto-paginates via STARTINDEX on 2.0.0 until this cap or the result set is exhausted). Each returned feature is one billable event. Default 1000.

## `pageSize` (type: `integer`):

Server-side page size requested per GetFeature call (COUNT on 2.0.0 / MAXFEATURES on 1.1.0). The actor auto-follows pages regardless. Most servers cap this around 1000–10000. Leave at the default unless you have a reason to change it.

## `extraParams` (type: `object`):

Arbitrary extra query-string parameters appended to each GetFeature request, as a JSON object — the generic passthrough for vendor-specific keys (e.g. {"propertyName": "NAME,POPULATION"} or a MapServer {"map": "/path/to.map"}). The reserved WFS control keys (service/version/request/typenames/count/startindex/outputformat/srsname/bbox/cql\_filter/filter) are managed by the actor and ignored here. Leave empty for none.

## `bearerToken` (type: `string`):

Optional OAuth2 bearer token for auth-gated WFS deployments. Sent as Authorization: Bearer \*\*\*. NOT required for public services (MapServer, PDOK demos) — leave empty. Never logged.

## `extraHeaders` (type: `object`):

Optional extra HTTP headers to send with every request, as a JSON object, e.g. {"x-api-key": "..."} for a service that takes an API key in a header. Leave empty for public services.

## Actor input object example

```json
{
  "wfsUrl": "https://demo.mapserver.org/cgi-bin/wfs",
  "typeNames": [
    "cities"
  ],
  "listTypesOnly": false,
  "wfsVersion": "2.0.0",
  "maxFeatures": 1000,
  "pageSize": 100
}
```

# 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 = {
    "wfsUrl": "https://demo.mapserver.org/cgi-bin/wfs",
    "typeNames": [
        "cities"
    ],
    "maxFeatures": 1000,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/wfs-feature-extractor").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 = {
    "wfsUrl": "https://demo.mapserver.org/cgi-bin/wfs",
    "typeNames": ["cities"],
    "maxFeatures": 1000,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("datamule/wfs-feature-extractor").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 '{
  "wfsUrl": "https://demo.mapserver.org/cgi-bin/wfs",
  "typeNames": [
    "cities"
  ],
  "maxFeatures": 1000,
  "pageSize": 100
}' |
apify call datamule/wfs-feature-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datamule/wfs-feature-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WFS Feature Extractor",
        "description": "Point at ANY classic OGC WFS 2.0/1.1 service (GeoServer, MapServer, deegree, QGIS-Server) behind national & city SDIs. Reads GetCapabilities, pages GetFeature by bbox/CQL, returns flat feature rows (geometry, lon/lat, computed bbox, properties, SRS) from GeoJSON OR GML. Pay per feature.",
        "version": "0.1",
        "x-build-id": "ib9Uz8TPXELarztVk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamule~wfs-feature-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamule-wfs-feature-extractor",
                "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/datamule~wfs-feature-extractor/runs": {
            "post": {
                "operationId": "runs-sync-datamule-wfs-feature-extractor",
                "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/datamule~wfs-feature-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-datamule-wfs-feature-extractor",
                "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": [
                    "wfsUrl"
                ],
                "properties": {
                    "wfsUrl": {
                        "title": "WFS service URL",
                        "type": "string",
                        "description": "The base URL of ANY classic OGC WFS service (the older, XML GetCapabilities → GetFeature protocol — distinct from the modern JSON 'OGC API - Features'). This is the endpoint the service answers SERVICE=WFS&REQUEST=GetCapabilities on. Examples: https://demo.mapserver.org/cgi-bin/wfs (MapServer) or https://service.pdok.nl/lv/bag/wfs/v2_0 (PDOK / GeoServer). Any pre-existing query (e.g. ?map=...) is preserved."
                    },
                    "typeNames": {
                        "title": "Feature type name(s)",
                        "type": "array",
                        "description": "Feature type(s) to pull, e.g. ms:cities, bag:pand, or a bare local name like cities. Accepts one or more. Leave EMPTY to run in discovery mode (list every feature type the service advertises). Turn on \"List feature types only\" below to just browse the catalog first.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listTypesOnly": {
                        "title": "List feature types only (discovery)",
                        "type": "boolean",
                        "description": "When on, the actor only reads GetCapabilities and returns one row per advertised feature type (name, title, abstract, default CRS, supported output formats) — it does NOT fetch any features. Use this to discover what a service exposes, then set Feature type name(s) + a bbox/CQL filter to extract features.",
                        "default": false
                    },
                    "wfsVersion": {
                        "title": "WFS version",
                        "enum": [
                            "2.0.0",
                            "1.1.0",
                            "1.0.0"
                        ],
                        "type": "string",
                        "description": "Preferred WFS protocol version. The actor negotiates automatically — if the service doesn't speak the preferred version it falls back through 2.0.0 → 1.1.0 → 1.0.0 — and the version reported on every row is the one the server actually served.",
                        "default": "2.0.0"
                    },
                    "bbox": {
                        "title": "Bounding box (BBOX)",
                        "type": "string",
                        "description": "Optional spatial filter passed as the WFS BBOX parameter, as a comma string. WFS 2.0.0 form: minX,minY,maxX,maxY,CRS (e.g. -60,-40,-50,-30,urn:ogc:def:crs:EPSG::4326). Axis order and CRS follow the target service — check GetCapabilities. Leave empty for no spatial filter."
                    },
                    "cqlFilter": {
                        "title": "CQL filter",
                        "type": "string",
                        "description": "Optional CQL_FILTER expression (GeoServer / MapServer support this vendor extension), e.g. POPULATION > 1000000 or NAME = 'Manila'. Mutually exclusive with an XML Filter below — if both are set, CQL is sent. Leave empty for no attribute filter."
                    },
                    "filter": {
                        "title": "OGC XML filter",
                        "type": "string",
                        "description": "Optional raw OGC Filter Encoding XML passed as the FILTER parameter (the standards-based alternative to CQL, supported by all classic WFS servers). Advanced — leave empty unless you have a specific <fes:Filter>…</fes:Filter> to send."
                    },
                    "outputFormat": {
                        "title": "Output format override",
                        "type": "string",
                        "description": "Optional OUTPUTFORMAT override. By default the actor auto-negotiates: it prefers a GeoJSON format the type advertises, and falls back to the server-default GML (which it fully parses to the same row shape). Only set this to force a specific token, e.g. application/json; subtype=geojson or text/xml; subtype=gml/3.1.1. Leave empty for auto."
                    },
                    "srsName": {
                        "title": "Output SRS (srsName)",
                        "type": "string",
                        "description": "Optional SRSNAME to request features reprojected to a specific CRS, e.g. urn:ogc:def:crs:EPSG::4326 or EPSG:3857 (only honored if the type advertises that CRS). Leave empty to use the service's default CRS."
                    },
                    "maxFeatures": {
                        "title": "Max features (total)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total number of features to pull across all pages and feature types (the actor auto-paginates via STARTINDEX on 2.0.0 until this cap or the result set is exhausted). Each returned feature is one billable event. Default 1000.",
                        "default": 1000
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Server-side page size requested per GetFeature call (COUNT on 2.0.0 / MAXFEATURES on 1.1.0). The actor auto-follows pages regardless. Most servers cap this around 1000–10000. Leave at the default unless you have a reason to change it.",
                        "default": 100
                    },
                    "extraParams": {
                        "title": "Extra query parameters",
                        "type": "object",
                        "description": "Arbitrary extra query-string parameters appended to each GetFeature request, as a JSON object — the generic passthrough for vendor-specific keys (e.g. {\"propertyName\": \"NAME,POPULATION\"} or a MapServer {\"map\": \"/path/to.map\"}). The reserved WFS control keys (service/version/request/typenames/count/startindex/outputformat/srsname/bbox/cql_filter/filter) are managed by the actor and ignored here. Leave empty for none."
                    },
                    "bearerToken": {
                        "title": "Bearer token (optional)",
                        "type": "string",
                        "description": "Optional OAuth2 bearer token for auth-gated WFS deployments. Sent as Authorization: Bearer ***. NOT required for public services (MapServer, PDOK demos) — leave empty. Never logged."
                    },
                    "extraHeaders": {
                        "title": "Extra request headers",
                        "type": "object",
                        "description": "Optional extra HTTP headers to send with every request, as a JSON object, e.g. {\"x-api-key\": \"...\"} for a service that takes an API key in a header. Leave empty for public services."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
