# Location Page Consistency Checker (`junipr/location-page-consistency-checker`) Actor

Audit multi-location pages for consistent addresses, hours, schema, titles, and location content.

- **URL**: https://apify.com/junipr/location-page-consistency-checker.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.90 / 1,000 page auditeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Location Page Consistency Checker

Compare location page fields across a supplied multi-location set and expose missing or inconsistent values.

Location Page Consistency Checker is designed for local SEO teams, multi-location operators, agencies, franchise systems, and developers maintaining location pages. It processes only the bounded inputs you provide, produces deterministic dataset rows, and writes optional JSON and Markdown reports. Empty, blocked, or malformed sources are represented as diagnostics rather than successful invented data.

### Common Uses

- Find location pages missing addresses, hours, phones, local titles, or LocalBusiness schema.
- Compare hours against an explicit business-wide expectation.
- Normalize phone formatting for a consistent comparison.
- Extract basic location fields from supplied or fetched JSON-LD.

### How The Analysis Works

- Each location receives five field comparisons: address, phone, hours, title, and schema type.
- Addresses must be present. Phones must have a valid digit length. Titles should include the supplied city or locality.
- Expected hours and phone values can be supplied explicitly; otherwise the actor uses a deterministic common-value baseline where appropriate.
- Missing, invalid, inconsistent, and missing-location-term outcomes remain distinct so remediation can be targeted.

The actor processes source groups in order. It stops before another paid row when the run's event charge limit is reached. Rows already charged and written remain available, and the summary marks the run as truncated. Source-access diagnostics do not pretend that an audit or analysis succeeded.

### Input

- `records`: location ID, city, address, phone, hours, title, schemaType, and pageUrl.
- `html`: one location page containing a title and optional LocalBusiness JSON-LD.
- `urls or sourceUrl`: public pages fetched only when fetchUrls is true.
- `expectedHours, expectedPhone, and expectedSchemaType override inferred expectations.`
- `fetchUrls` defaults to `false`. Set it to `true` only for public HTTP(S) sources.
- `fetchTimeoutMs` is bounded between 1,000 and 30,000 milliseconds.
- `maxTextBytes` limits each fetched response to at most 1,000,000 bytes.
- `includeReport` controls the charged JSON and Markdown report artifacts.
- `dryRun` validates the input shape without paid dataset output.

Direct top-level source fields are useful for one source group. Use `targets` for multiple independent groups. Public URL retrieval rejects embedded credentials, redirects, localhost, private and reserved network ranges, DNS answers that resolve privately, oversized responses, and requests that exceed the timeout.

### Example Input

```json
{
  "targets": [
    {
      "sourceId": "fixture-location-pages",
      "records": [
        {
          "id": "nashville",
          "city": "Nashville",
          "address": "101 Main St, Nashville, TN",
          "phone": "(615) 555-0199",
          "hours": "Mon-Fri 8-5",
          "title": "Roof Repair Nashville",
          "schemaType": "LocalBusiness",
          "pageUrl": "https://example.com/nashville"
        },
        {
          "id": "franklin",
          "city": "Franklin",
          "address": "202 Main St, Franklin, TN",
          "phone": "(615) 555-0199",
          "hours": "Mon-Fri 8-5",
          "title": "Roof Repair Franklin",
          "schemaType": "LocalBusiness",
          "pageUrl": "https://example.com/franklin"
        },
        {
          "id": "murfreesboro",
          "city": "Murfreesboro",
          "address": "",
          "phone": "(629) 555-0100",
          "hours": "",
          "title": "Services",
          "schemaType": "",
          "pageUrl": "https://example.com/murfreesboro"
        }
      ]
    }
  ],
  "maxTargets": 1,
  "maxItems": 25,
  "includeReport": true,
  "fetchUrls": false
}
````

### Dataset Output

- locationId and pageUrl tie every comparison to the source location.
- fieldName, expectedValue, and observedValue preserve the comparison.
- mismatchType identifies match, missing, invalid, inconsistent, or missing-location-term.
- The report totals audited locations, compared fields, mismatches, and blocked locations.

Every row also includes a stable `rowId`, `sourceId`, optional `sourceUrl`, `sourceType`, status, severity, score, summary, recommendation, timestamp, pricing tier, and the event name associated with that row. The dataset schema is strict, so examples and runtime rows use the same field set.

### Example Output

```json
[
  {
    "rowId": "location-page-consistency-checker_c400a5ac2c753887",
    "sourceId": "fixture-location-pages",
    "sourceUrl": null,
    "sourceType": "inline-records",
    "status": "ok",
    "severity": "info",
    "score": 100,
    "summary": "nashville address: match.",
    "recommendation": "Add a complete street address unique to this location.",
    "checkedAt": "2026-07-02T00:00:00.000Z",
    "pricingTemplate": "W1 — Web/domain audit",
    "pricingEventName": "record-extracted",
    "locationId": "nashville",
    "fieldName": "address",
    "expectedValue": "present",
    "observedValue": "101 Main St, Nashville, TN",
    "pageUrl": "https://example.com/nashville",
    "mismatchType": "match"
  },
  {
    "rowId": "location-page-consistency-checker_e81a1a56709a816f",
    "sourceId": "fixture-location-pages",
    "sourceUrl": null,
    "sourceType": "inline-records",
    "status": "ok",
    "severity": "info",
    "score": 100,
    "summary": "nashville phone: match.",
    "recommendation": "Add a valid phone number and keep intentional shared numbers documented.",
    "checkedAt": "2026-07-02T00:00:00.000Z",
    "pricingTemplate": "W1 — Web/domain audit",
    "pricingEventName": "record-extracted",
    "locationId": "nashville",
    "fieldName": "phone",
    "expectedValue": "valid phone",
    "observedValue": "(615) 555-0199",
    "pageUrl": "https://example.com/nashville",
    "mismatchType": "match"
  }
]
```

### Report Artifacts

When `includeReport` is enabled and report charges succeed, the default key-value store receives:

- `LOCATION_PAGE_CONSISTENCY_CHECKER_RESULTS.json` with the charged dataset rows.
- `LOCATION_PAGE_CONSISTENCY_CHECKER_SUMMARY.json` with counts, truncation state, and the run recommendation.
- `LOCATION_PAGE_CONSISTENCY_CHECKER_REPORT.md` with a buyer-readable report.

The dataset remains the row-level source of truth. The summary and Markdown report are derived from rows that were actually emitted; they do not include rows stopped by a charge limit.

### Pay Per Event

This actor uses pay-per-event pricing. The configured event prices include platform usage, and the default maximum charge is $10.00. The actor charges before paid output and rejects partial charges.

- `actor-start`: $0.00500 per event. Charged before paid dataset output or the corresponding paid unit is emitted.
- `page-audited`: $0.00490 per event. Charged before paid dataset output or the corresponding paid unit is emitted.
- `record-extracted`: $0.00372 per event. Charged before paid dataset output or the corresponding paid unit is emitted.
- `finding-emitted`: $0.00372 per event. Charged before paid dataset output or the corresponding paid unit is emitted.
- `audit-report-generated`: $0.05000 per event. Charged before writing the buyer-ready report artifacts to key-value storage.

Discounted Store tiers are represented in the pricing metadata. Review the run's cost estimate and caps before increasing source counts. URL retrieval, proxy use, or external services are not silently enabled by the actor.

### Public Tasks

- **Audit public URLs for Location Page Consistency Checker issues:** Audit one public location page for address, phone, hours, title, and LocalBusiness schema fields.
- **Find Location Page Consistency Checker problems across a website:** Compare a capped multi-location record set and flag missing or inconsistent fields.
- **Generate a technical Location Page Consistency Checker report:** Create a field-level mismatch report for a supplied location page table.
- **Compare location hours and phone formatting:** Check shared hours and phone expectations while retaining intentional local differences.
- **Extract and validate LocalBusiness fields from page HTML:** Extract title, address, phone, hours, and schema type from one inline page.

Each task uses a small explicit input and sets a maximum item count. URL-based tasks enable fetching only where fetching is necessary to demonstrate the actor's purpose; inline tasks remain deterministic and network-free.

### Reading Results

Start with blocked or high-severity rows, then review attention or warning rows. Confirm the evidence and recommendation against your operating policy before making bulk changes. A pass means the supplied source satisfied the configured check; it is not a guarantee about data or behavior outside the source and rules evaluated in that run.

For repeated workflows, keep source IDs stable. Stable IDs make it easier to compare exports, trace a report row to the original input, and identify whether a change came from source data or configuration. Keep caps low while testing a new data shape, then increase them only after confirming row counts and expected event costs.

### Data Handling And Safety

Use public or authorized source material. Do not provide credentials in URLs. The actor does not attempt to bypass authentication, anti-bot controls, access restrictions, or private networks. Fetched bodies are held only for the run's bounded analysis. Dataset and report outputs may contain excerpts or field values from the supplied source, so avoid submitting secrets or personal data that should not appear in Apify storage.

### Limitations

- The actor does not query Google Business Profile or external directory listings.
- Shared phones or different hours may be intentional; use explicit expectations to represent those policies.
- JSON-LD extraction targets common LocalBusiness and Organization objects and does not execute JavaScript.
- Consistency findings should be reviewed against real business operations before bulk edits.

### FAQ

#### Does the actor invent missing values?

No. Missing values and unavailable sources become explicit gaps, mismatches, failures, or diagnostics.

#### Can I run it without network access?

Yes. Supply inline records, CSV, text, or HTML and leave `fetchUrls` disabled.

#### What happens at the charge limit?

The actor stops before the next paid output, preserves rows already written, and marks the summary as truncated. Optional report artifacts are written only when their report events are fully charged.

#### Should I treat every finding as an automatic change?

No. Findings are deterministic QA or analysis results based on supplied evidence. Review business context, source quality, and intentional exceptions before acting.

# Actor input Schema

## `targets` (type: `array`):

Independent bounded source groups. Direct top-level source fields take precedence when supplied.

## `urls` (type: `array`):

Public HTTP(S) pages or data sources to retrieve only when Fetch URLs is enabled.

## `sourceId` (type: `string`):

Stable identifier for a direct source group.

## `sourceUrl` (type: `string`):

One public HTTP(S) source URL for direct input.

## `html` (type: `string`):

Html used by the actor-specific analyzer.

## `records` (type: `array`):

Structured source rows. Each object is preserved and evaluated without enrichment.

## `expectedHours` (type: `string`):

Expected Hours used by the actor-specific analyzer.

## `expectedPhone` (type: `string`):

Expected Phone used by the actor-specific analyzer.

## `expectedSchemaType` (type: `string`):

Expected Schema Type used by the actor-specific analyzer.

## `fetchUrls` (type: `boolean`):

Retrieve public HTTP(S) sources with redirect, private-address, timeout, and byte-limit controls.

## `fetchTimeoutMs` (type: `integer`):

Per-source network timeout in milliseconds.

## `maxTargets` (type: `integer`):

Maximum independent source groups processed in one run.

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

Maximum source records, comparison rows, checks, or locations processed per target.

## `maxTextBytes` (type: `integer`):

Maximum bytes accepted from one fetched source.

## `includeReport` (type: `boolean`):

Write buyer-ready JSON and Markdown artifacts after report billing succeeds.

## `dryRun` (type: `boolean`):

Validate input without charges or paid dataset output.

## `debug` (type: `boolean`):

Enable debug-level diagnostics.

## Actor input object example

```json
{
  "targets": [],
  "urls": [],
  "sourceId": "",
  "sourceUrl": "",
  "html": "",
  "records": [],
  "expectedHours": "",
  "expectedPhone": "",
  "expectedSchemaType": "",
  "fetchUrls": false,
  "fetchTimeoutMs": 10000,
  "maxTargets": 1,
  "maxItems": 25,
  "maxTextBytes": 500000,
  "includeReport": true,
  "dryRun": false,
  "debug": false
}
```

# Actor output Schema

## `results` (type: `string`):

Location field comparisons with expected values and mismatch classifications.

## `resultsJson` (type: `string`):

Charged results export when Include Report is enabled.

## `summary` (type: `string`):

Run totals, truncation state, and recommendation.

## `markdownReport` (type: `string`):

Buyer-ready report when report billing succeeds.

# 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("junipr/location-page-consistency-checker").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("junipr/location-page-consistency-checker").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 junipr/location-page-consistency-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=junipr/location-page-consistency-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Location Page Consistency Checker",
        "description": "Audit multi-location pages for consistent addresses, hours, schema, titles, and location content.",
        "version": "1.0",
        "x-build-id": "VUtFh9qmhHu2pUvHI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~location-page-consistency-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-location-page-consistency-checker",
                "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/junipr~location-page-consistency-checker/runs": {
            "post": {
                "operationId": "runs-sync-junipr-location-page-consistency-checker",
                "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/junipr~location-page-consistency-checker/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-location-page-consistency-checker",
                "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": {
                    "targets": {
                        "title": "Targets",
                        "type": "array",
                        "description": "Independent bounded source groups. Direct top-level source fields take precedence when supplied.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "urls": {
                        "title": "Public URLs",
                        "type": "array",
                        "description": "Public HTTP(S) pages or data sources to retrieve only when Fetch URLs is enabled.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "sourceId": {
                        "title": "Source ID",
                        "type": "string",
                        "description": "Stable identifier for a direct source group.",
                        "default": ""
                    },
                    "sourceUrl": {
                        "title": "Source URL",
                        "type": "string",
                        "description": "One public HTTP(S) source URL for direct input.",
                        "default": ""
                    },
                    "html": {
                        "title": "Html",
                        "type": "string",
                        "description": "Html used by the actor-specific analyzer.",
                        "default": ""
                    },
                    "records": {
                        "title": "Records",
                        "type": "array",
                        "description": "Structured source rows. Each object is preserved and evaluated without enrichment.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "expectedHours": {
                        "title": "Expected Hours",
                        "type": "string",
                        "description": "Expected Hours used by the actor-specific analyzer.",
                        "default": ""
                    },
                    "expectedPhone": {
                        "title": "Expected Phone",
                        "type": "string",
                        "description": "Expected Phone used by the actor-specific analyzer.",
                        "default": ""
                    },
                    "expectedSchemaType": {
                        "title": "Expected Schema Type",
                        "type": "string",
                        "description": "Expected Schema Type used by the actor-specific analyzer.",
                        "default": ""
                    },
                    "fetchUrls": {
                        "title": "Fetch URLs",
                        "type": "boolean",
                        "description": "Retrieve public HTTP(S) sources with redirect, private-address, timeout, and byte-limit controls.",
                        "default": false
                    },
                    "fetchTimeoutMs": {
                        "title": "Fetch Timeout",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Per-source network timeout in milliseconds.",
                        "default": 10000
                    },
                    "maxTargets": {
                        "title": "Max Targets",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum independent source groups processed in one run.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum source records, comparison rows, checks, or locations processed per target.",
                        "default": 25
                    },
                    "maxTextBytes": {
                        "title": "Max Source Bytes",
                        "minimum": 1000,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum bytes accepted from one fetched source.",
                        "default": 500000
                    },
                    "includeReport": {
                        "title": "Include Report",
                        "type": "boolean",
                        "description": "Write buyer-ready JSON and Markdown artifacts after report billing succeeds.",
                        "default": true
                    },
                    "dryRun": {
                        "title": "Dry Run",
                        "type": "boolean",
                        "description": "Validate input without charges or paid dataset output.",
                        "default": false
                    },
                    "debug": {
                        "title": "Debug Logs",
                        "type": "boolean",
                        "description": "Enable debug-level diagnostics.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
