# Open311 Service Request Extractor (`datamule/open311-service-request-extractor`) Actor

Point at any Open311 (GeoReport v2) city for one structured row per 311 service request: id, status, service, description, address, coordinates, media, agency, timestamps. Also pull the service-type catalog and the endpoint discovery — the open municipal-311 standard, anonymous read.

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

## Pricing

from $0.35 / 1,000 records

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

### What does Open311 Service Request Extractor do?

**Open311 Service Request Extractor turns municipal 311 feeds into structured, agent-ready records.** Point it at any compatible [Open311 GeoReport v2](https://www.open311.org/) jurisdiction to collect public service requests, the jurisdiction's service catalog, or its discovery document. Request rows include the service-request ID, status, service type, description, address, coordinates, media, timestamps, source identity, and the complete source object in `_raw`.

Run it on Apify to access results through the API, schedule recurring collection, connect datasets to other tools, and monitor runs without maintaining scraper infrastructure.

### Why use Open311 Service Request Extractor?

- **Municipal operations agents:** monitor new or unresolved pothole, sanitation, parking, graffiti, and streetlight reports.
- **Civic research:** compare issue types, response states, and reporting patterns across compatible jurisdictions.
- **Alerts and workflows:** feed new requests into a queue, dashboard, geospatial pipeline, or incident-triage agent.
- **Service discovery:** list valid `service_code` values before building a filtered request workflow.
- **Lossless downstream processing:** use normalized columns for common analysis while retaining each complete source object in `_raw`.

### How to use Open311 Service Request Extractor

1. Open the Actor's **Input** tab.
2. Paste an Open311 jurisdiction base URL or full JSON endpoint.
3. Choose `requests`, `services`, or `discovery` mode.
4. Keep the default 25-row cap for a small first run, or set another positive cap.
5. Start the run and open the **Dataset** tab to inspect or export the rows.

Try this exact input:

```json
{"jurisdiction":"https://mobile311.sfgov.org","maxRecords":25,"mode":"requests"}
````

### Input

| Field | Type | Description |
|---|---|---|
| `jurisdiction` | string | One Open311 base URL or full `requests.json`, `services.json`, or `discovery.json` endpoint. |
| `jurisdictions` | array | Optional multi-city list. The global row cap applies across all sources. |
| `mode` | string | `requests` (default), `services`, or `discovery`. |
| `maxRecords` | integer | Global output cap. Omitted, invalid, or non-positive values resolve to **25**; every explicit positive cap is preserved. |
| `serviceCode` | string | Requests-mode filter passed as `service_code`. Run services mode to discover valid codes. |
| `status` | string | Requests-mode filter: all, `open`, or `closed`. |
| `startDate`, `endDate` | string | Optional RFC 3339 date-time window for requests. |
| `serviceRequestId` | string | One ID or a comma-separated list of request IDs. |
| `jurisdictionId` | string | Optional identifier for multi-tenant Open311 servers. |
| `token` | secret string | Optional bearer credential for a jurisdiction that requires authentication. It is never logged. |
| `extraHeaders` | object | Optional request headers for a gateway-fronted source. Header values are never logged. |

### Output

Fresh local acceptance with the exact try input above returned 25 genuine service requests and stopped at the cap. The following is an abridged row from that San Francisco Open311 run; actual dataset rows include every nullable schema column plus the complete source object in `_raw`.

```json
{
  "_type": "service_request",
  "_source": "https://mobile311.sfgov.org",
  "_endpoint": "https://mobile311.sfgov.org/open311/v2/requests.json",
  "_mode": "requests",
  "_software": "open311",
  "serviceRequestId": "101004471550",
  "status": "open",
  "serviceName": "Blocked driveway and illegal parking",
  "serviceCode": "MTA:Parking Enforcement:General Enforcement",
  "description": "Jeep blocking pedestrian path",
  "requestedDatetime": "2026-07-21T02:54:51Z",
  "updatedDatetime": "2026-07-21T02:55:29Z",
  "address": "164 29 Th St",
  "lat": 37.74398683,
  "long": -122.42360781
}
```

You can download the dataset in formats such as **JSON, HTML, CSV, or Excel**, or read it through the Apify API.

### Data table and field dictionary

| Field | Meaning |
|---|---|
| `_type` | `service_request`, `service`, or `discovery`. |
| `_source`, `_jurisdiction` | Jurisdiction value supplied to the Actor and optional multi-tenant jurisdiction ID. |
| `_endpoint` | Resolved Open311 JSON endpoint. |
| `_mode`, `_software` | Normalized mode and `open311` software identity. |
| `serviceRequestId` | Jurisdiction-issued request ID. |
| `status`, `statusNotes` | Current request state and optional status detail. |
| `serviceName`, `serviceCode` | Human-readable service and machine filter code. |
| `description` | Public issue description supplied by the source. |
| `requestedDatetime`, `updatedDatetime`, `expectedDatetime` | Normalized source timestamps when present. |
| `address`, `addressId`, `zipcode`, `lat`, `long` | Source-provided location fields. |
| `mediaUrl` | Optional public media URL. |
| `requestToken` | Source-provided Open311 request-tracking token, when present. |
| `agencyResponsible`, `serviceNotice` | Optional routing and service-level information. |
| `metadata`, `type`, `group`, `keywords` | Service-catalog fields used in `services` mode. |
| `changeset`, `contact`, `keyService`, `specification`, `endpointUrls`, `endpoints` | Discovery fields used in `discovery` mode. |
| `_raw` | Complete, lossless JSON object returned by the source. |

### How much does it cost to extract Open311 data?

The active FREE-tier pay-per-event price is **$0.0005 per emitted `record`**. The default first run emits at most 25 rows, so its FREE-tier PPE event-charge ceiling is:

`25 × $0.0005 = $0.0125`

This is an **event-charge ceiling**, not the total run cost. Apify infrastructure usage, such as compute, storage, or a user-selected proxy, is separate. A smaller positive cap lowers the ceiling; a larger positive cap raises it proportionally.

### Tips, coverage, freshness, and limits

- Start with `services` mode to discover jurisdiction-specific service codes, then use `serviceCode` in requests mode.
- Use `startDate`, `endDate`, and `status` to reduce volume and focus an alerting or monitoring job.
- `maxRecords` is global across a multi-jurisdiction run, not a per-city cap.
- Open311 servers control data freshness and retention. Results represent what the source returned at run time; many request feeds default to a recent window.
- Pagination behavior varies because GeoReport v2 does not standardize it. The Actor de-duplicates request IDs and stops when a server repeats a page or the global cap is reached.
- Missing optional fields remain `null`; they are not fabricated.

### FAQ, public-data scope, troubleshooting, and support

**Which sources are supported?** Compatible Open311 GeoReport v2 JSON endpoints. A normal website root is accepted only when the standard `/open311/v2/` paths exist. If a root is invalid, use the jurisdiction's full JSON endpoint.

**Why was a source skipped after returning HTML?** The URL is probably a website page, anti-bot interstitial, or non-Open311 endpoint. Confirm that `requests.json`, `services.json`, or `discovery.json` returns JSON.

**What if the source requires authentication?** Supply your own `token` or `extraHeaders`. The Actor does not bypass access controls. Invalid credentials, forbidden replies, and unavailable sources are skipped with a warning; a run where every source is invalid fails clearly.

**Why did a valid run return zero rows?** The selected date range, status, service code, or request ID may have no matches. Widen or remove filters, try `requests` mode, or check the source directly. A valid zero-row response is kept distinct from an invalid source.

**Is the data private?** This Actor is designed for public civic-data endpoints. Records can still contain addresses, free-text descriptions, or media supplied to a municipality. Review the source's terms, applicable privacy rules, and your downstream retention policy before redistributing data.

Open311 implementations differ and can change without notice. Use the Actor's **Issues** tab to report a source-specific problem or request a custom integration.

# Actor input Schema

## `jurisdiction` (type: `string`):

An Open311 GeoReport v2 jurisdiction. Paste either a base URL (https://mobile311.sfgov.org) — the /open311/v2/<endpoint>.json path is appended for you — OR a full endpoint (https://mobile311.sfgov.org/open311/v2/requests.json). Open311 is the open civic standard for municipal 311 service requests (potholes, graffiti, streetlights…); every adopting city serves the identical anonymous-read grammar. Find adopting jurisdictions in the registry at github.com/open311/open311.github.io (data/servers.yml). To query several cities at once, use Jurisdictions (array) instead.

## `jurisdictions` (type: `array`):

Optional list of Open311 jurisdiction URLs (base or full endpoint) to query in turn (overrides / augments the single Jurisdiction URL). A source that is unreachable, auth-gated, or not an Open311 host is skipped with a warning and the run continues with the others.

## `mode` (type: `string`):

What to extract. requests (default): the public service-request feed — one row per 311 request (id, status, service, description, address, coordinates, media, timestamps). services: the service catalog — one row per request type the jurisdiction offers. discovery: the endpoint self-description (/discovery.json) — one row (changeset, contact, specification, endpoint URLs).

## `serviceCode` (type: `string`):

REQUESTS MODE. Filter the feed to a single Open311 service\_code (a request type from the services catalog), passed through to the API's ?service\_code= param. Leave empty for all service types. Run services mode first to list the valid codes for a jurisdiction.

## `status` (type: `string`):

REQUESTS MODE. Filter the feed by request status, passed through to ?status=. Open311 defines two values: open or closed. Leave empty for both.

## `startDate` (type: `string`):

REQUESTS MODE. Only requests with a requested\_datetime at or after this instant, passed through to ?start\_date=. Use RFC-3339 / ISO-8601, e.g. 2026-07-01T00:00:00Z. Leave empty for the server default window (typically the most recent 90 days).

## `endDate` (type: `string`):

REQUESTS MODE. Only requests with a requested\_datetime at or before this instant, passed through to ?end\_date=. Use RFC-3339 / ISO-8601, e.g. 2026-07-07T00:00:00Z. Leave empty for now.

## `serviceRequestId` (type: `string`):

REQUESTS MODE. Fetch one or more specific requests by id, passed through to ?service\_request\_id= (a comma-separated list per the spec). Leave empty to list the feed.

## `jurisdictionId` (type: `string`):

Optional Open311 jurisdiction\_id, passed through to the API. Only needed for multi-tenant servers that host several jurisdictions behind one endpoint and require it to disambiguate; most single-city hosts ignore it.

## `maxRecords` (type: `integer`):

A GLOBAL cap on the number of rows to emit across ALL sources. Defaults to 25 rows when omitted, invalid, or non-positive. Each emitted row is one billable record event at $0.0005 on the FREE tier, and pagination stops as soon as the cap is reached. Set a smaller or larger positive value to change the cap.

## `token` (type: `string`):

Optional API key / token for a jurisdiction that gates its request feed (sent as an Authorization: Bearer header). NOT required for the public standard feeds. Never logged.

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

Optional extra HTTP headers as a JSON object, e.g. {"x-api-key": "..."} for a gated / gateway-fronted jurisdiction. Not required for the public feeds. Header values are never logged.

## Actor input object example

```json
{
  "jurisdiction": "https://mobile311.sfgov.org",
  "mode": "requests",
  "status": "",
  "maxRecords": 25
}
```

# 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 = {
    "jurisdiction": "https://mobile311.sfgov.org",
    "maxRecords": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/open311-service-request-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 = {
    "jurisdiction": "https://mobile311.sfgov.org",
    "maxRecords": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("datamule/open311-service-request-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 '{
  "jurisdiction": "https://mobile311.sfgov.org",
  "maxRecords": 25
}' |
apify call datamule/open311-service-request-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open311 Service Request Extractor",
        "description": "Point at any Open311 (GeoReport v2) city for one structured row per 311 service request: id, status, service, description, address, coordinates, media, agency, timestamps. Also pull the service-type catalog and the endpoint discovery — the open municipal-311 standard, anonymous read.",
        "version": "0.1",
        "x-build-id": "TX3bNB3metmZ9gcOL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamule~open311-service-request-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamule-open311-service-request-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~open311-service-request-extractor/runs": {
            "post": {
                "operationId": "runs-sync-datamule-open311-service-request-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~open311-service-request-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-datamule-open311-service-request-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",
                "properties": {
                    "jurisdiction": {
                        "title": "Open311 jurisdiction URL",
                        "type": "string",
                        "description": "An Open311 GeoReport v2 jurisdiction. Paste either a base URL (https://mobile311.sfgov.org) — the /open311/v2/<endpoint>.json path is appended for you — OR a full endpoint (https://mobile311.sfgov.org/open311/v2/requests.json). Open311 is the open civic standard for municipal 311 service requests (potholes, graffiti, streetlights…); every adopting city serves the identical anonymous-read grammar. Find adopting jurisdictions in the registry at github.com/open311/open311.github.io (data/servers.yml). To query several cities at once, use Jurisdictions (array) instead."
                    },
                    "jurisdictions": {
                        "title": "Jurisdictions (multi-city, optional)",
                        "type": "array",
                        "description": "Optional list of Open311 jurisdiction URLs (base or full endpoint) to query in turn (overrides / augments the single Jurisdiction URL). A source that is unreachable, auth-gated, or not an Open311 host is skipped with a warning and the run continues with the others.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "requests",
                            "services",
                            "discovery"
                        ],
                        "type": "string",
                        "description": "What to extract. requests (default): the public service-request feed — one row per 311 request (id, status, service, description, address, coordinates, media, timestamps). services: the service catalog — one row per request type the jurisdiction offers. discovery: the endpoint self-description (/discovery.json) — one row (changeset, contact, specification, endpoint URLs).",
                        "default": "requests"
                    },
                    "serviceCode": {
                        "title": "Service code (requests mode)",
                        "type": "string",
                        "description": "REQUESTS MODE. Filter the feed to a single Open311 service_code (a request type from the services catalog), passed through to the API's ?service_code= param. Leave empty for all service types. Run services mode first to list the valid codes for a jurisdiction."
                    },
                    "status": {
                        "title": "Status (requests mode)",
                        "enum": [
                            "",
                            "open",
                            "closed"
                        ],
                        "type": "string",
                        "description": "REQUESTS MODE. Filter the feed by request status, passed through to ?status=. Open311 defines two values: open or closed. Leave empty for both.",
                        "default": ""
                    },
                    "startDate": {
                        "title": "Start date (requests mode)",
                        "type": "string",
                        "description": "REQUESTS MODE. Only requests with a requested_datetime at or after this instant, passed through to ?start_date=. Use RFC-3339 / ISO-8601, e.g. 2026-07-01T00:00:00Z. Leave empty for the server default window (typically the most recent 90 days)."
                    },
                    "endDate": {
                        "title": "End date (requests mode)",
                        "type": "string",
                        "description": "REQUESTS MODE. Only requests with a requested_datetime at or before this instant, passed through to ?end_date=. Use RFC-3339 / ISO-8601, e.g. 2026-07-07T00:00:00Z. Leave empty for now."
                    },
                    "serviceRequestId": {
                        "title": "Service request ID(s) (requests mode)",
                        "type": "string",
                        "description": "REQUESTS MODE. Fetch one or more specific requests by id, passed through to ?service_request_id= (a comma-separated list per the spec). Leave empty to list the feed."
                    },
                    "jurisdictionId": {
                        "title": "Jurisdiction ID (optional)",
                        "type": "string",
                        "description": "Optional Open311 jurisdiction_id, passed through to the API. Only needed for multi-tenant servers that host several jurisdictions behind one endpoint and require it to disambiguate; most single-city hosts ignore it."
                    },
                    "maxRecords": {
                        "title": "Max records (global cap)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "A GLOBAL cap on the number of rows to emit across ALL sources. Defaults to 25 rows when omitted, invalid, or non-positive. Each emitted row is one billable record event at $0.0005 on the FREE tier, and pagination stops as soon as the cap is reached. Set a smaller or larger positive value to change the cap.",
                        "default": 25
                    },
                    "token": {
                        "title": "API key / token",
                        "type": "string",
                        "description": "Optional API key / token for a jurisdiction that gates its request feed (sent as an Authorization: Bearer header). NOT required for the public standard feeds. Never logged."
                    },
                    "extraHeaders": {
                        "title": "Extra request headers",
                        "type": "object",
                        "description": "Optional extra HTTP headers as a JSON object, e.g. {\"x-api-key\": \"...\"} for a gated / gateway-fronted jurisdiction. Not required for the public feeds. Header values are never logged."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
