# USGS Seismic Risk Profiler (Official API) (`saint_person/usgs-seismic-risk-profiler`) Actor

Analyze earthquake risk and geological hazards for any US location using official USGS data. Stable API, no auth required.

- **URL**: https://apify.com/saint\_person/usgs-seismic-risk-profiler.md
- **Developed by:** [saint person](https://apify.com/saint_person) (community)
- **Categories:** Real estate, MCP servers, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 actor starts

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🌍 USGS Seismic Risk Profiler

> 🚀 **Assess earthquake risk and seismic hazards for any US location in seconds.** Enter latitude/longitude and get **recent earthquake activity, risk levels, and geological hazards** from official USGS data. Built on the official USGS API - no scraping, no breakage.

<!-- Optional: add a brand banner image here once you have one: ![banner](https://...) -->

> 🕒 **Last updated:** 2026-07-07 · 📊 **9 fields** per location risk assessment · 🌎 **Official USGS data** · 📍 **Live earthquake data** · 🔓 **No auth required**

> 🎁 **Try it free:** the free Apify plan returns up to **10 results per run** — enough to see the output quality. Any paid Apify plan unlocks full-size runs.

The USGS Seismic Risk Profiler analyzes earthquake history and geological hazards for any location in the continental US. Enter any latitude/longitude coordinates and the Actor queries the official USGS Earthquake Hazards Program API, returning recent seismic activity, calculated risk levels, and magnitude data.

Results are flat JSON rows ready for CSV, Excel, or direct API consumption - built for real estate professionals, insurance underwriters, infrastructure planners, and AI agents evaluating location risk automatically.

| 🎯 Target Audience | 💡 Primary Use Cases |
| --- | --- |
| Real estate investors, insurance underwriters, infrastructure planners, civil engineers, disaster risk analysts, AI location-intelligence agents | Property risk assessment, real estate due diligence, insurance underwriting, infrastructure planning, geohazard analysis |

---

### 📋 What USGS Seismic Risk Profiler does

One input, one run, a clean dataset:

- 📊 **Live earthquake data.** Pulls recent seismic activity within your chosen radius (10-500 km).
- 📍 **Distance calculations.** Computes exact distance from your target location to each earthquake.
- ⚠️ **Risk classification.** Automatic risk level (HIGH/MODERATE/LOW) based on magnitude and proximity.
- 📈 **Historical depth & magnitude.** Depth in km, moment magnitude, and felt-report counts per event.

> 💡 **Why it matters:** Most properties never get assessed for earthquake risk until after a loss. Real-time risk data sourced directly from USGS means you can evaluate any location's seismic exposure in minutes instead of waiting for expensive geological surveys.

---

### 🎬 Full demo

🚧 Video walkthrough coming soon — the Quick Start below takes under 3 minutes end to end.

---

### ⚙️ Input

| Input | Type | Default | Behavior |
| --- | --- | --- | --- |
| `latitude` | number | `40.7128` | Latitude of the location to assess. |
| `longitude` | number | `-74.0060` | Longitude of the location. |
| `radiusKm` | integer | `100` | Search radius in kilometers (10-500). Optional. |
| `daysBack` | integer | `30` | Historical range in days (1-365). Optional. |

**Example: assess a property in New York**

```json
{
  "latitude": 40.7128,
  "longitude": -74.0060,
  "radiusKm": 100,
  "daysBack": 30
}
````

**Example: quick scan of a Bay Area location**

```json
{
  "latitude": 37.7749,
  "longitude": -122.4194,
  "radiusKm": 50
}
```

> ⚠️ **Good to know:** USGS data is updated in real-time as earthquakes occur. Risk assessments are based on recent activity; for long-term seismic hazard mapping, combine with USGS National Seismic Hazard Maps.

***

### 📊 Output

Each location risk assessment returns **9 fields**. Download as CSV, Excel, JSON, or XML, or consume via the Apify API.

#### 🧾 Schema

| Field | Type | Example |
| --- | --- | --- |
| 📍 `location` | string | `"40.7128, -74.006"` |
| 📊 `magnitude` | number | `3.2` |
| 🌍 `depth_km` | number | `8.0` |
| 🎯 `distance_km` | number | `4.0` |
| 📝 `place` | string | `"12 km NE of Manhattan, New York"` |
| ⏰ `time_utc` | number | `1688000000000` |
| ⚠️ `risk_level` | string | `"LOW"` |
| 🔬 `magType` | string | `"md"` |
| 👁️ `felt_reports` | integer | `45` |

#### 📦 Sample record

```json
{
  "location": "40.7128, -74.006",
  "magnitude": 3.2,
  "depth_km": 8.0,
  "distance_km": 4.0,
  "place": "12 km NE of Manhattan, New York",
  "time_utc": 1688000000000,
  "risk_level": "LOW",
  "magType": "md",
  "felt_reports": 45
}
```

***

### ✨ Why choose this Actor

| | Capability |
| --- | --- |
| 🌎 | **Official USGS data.** Not third-party aggregation or stale databases - live from the US Geological Survey. |
| 📍 | **Precise distance calculations.** Knows how far each earthquake was from your target location, not just the radius. |
| ⚠️ | **Risk-level classification.** Automatic scoring (HIGH/MODERATE/LOW) based on magnitude + proximity - no expert interpretation needed. |
| ⚡ | **Built on the official USGS Earthquake Hazards Program API.** Stable and durable — no breakage from page redesigns. |
| 🔁 | **Automatic retries.** Transient failures retry with backoff; errors are logged clearly, never silent. |
| 💳 | **Pay per result.** No subscription. A typical run costs $0.015 (typical run with 3-5 earthquakes). |

> 📊 Over 20,000 earthquakes happen annually in the US. Real-time risk data from USGS means you assess property seismic exposure in minutes instead of weeks.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
| --- | --- | --- | --- | --- |
| **⭐ USGS Seismic Risk Profiler** *(this Actor)* | $5 free credit, then pay-per-use | Continental US and territories with USGS seismic monitoring | **Live per run** | ⚡ 2 min |
| USGS Hazard Map (web) | Free | Static zoning map only | Historical | 🐢 Manual lookup per property |
| Commercial seismic services | $50-500/report | Detailed report, property-level | 1-7 days | 🏢 Slow turnaround |
| Manual copy-paste | Free | Current session only | One-shot | 🐢 Hours of clicking |

Pick this Actor when you want you want real-time earthquake risk data on demand - per location, instant.

***

### 🚀 How to use

1. 📝 **Sign up.** Create a free Apify account with $5 credit (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the USGS Seismic Risk Profiler page on the Apify Store.
3. ✏️ **Set your input.** Enter latitude and longitude of the location you want to assess — or just press Start, the prefilled example works.
4. 🚀 **Run it.** Watch results stream into the Dataset tab.
5. 📥 **Download.** Grab results as CSV, Excel, JSON, or XML — or pipe them anywhere via the Apify API.

> ⏱️ Total time from signup to downloaded dataset: **3–5 minutes.** No coding required.

***

### 💼 Business use cases

- 🏘️ **Real estate investors** - assess seismic risk before acquiring property; due diligence on portfolios; price adjustments based on risk data.
- 🏢 **Insurance underwriters** - rate premiums on earthquake exposure; flag high-risk zones for manual review.
- 🏗️ **Infrastructure planners** - identify seismic zones for critical infrastructure; design resilience into new projects.
- 🤖 **AI location intelligence** - agent calls the Actor via MCP, evaluates candidate properties automatically, scores by risk.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows:

- 🎓 **Research & academia** — empirical datasets for papers and coursework; longitudinal studies across scheduled snapshots; reproducible, citable data pulls.
- 🎨 **Personal & creative** — side projects, dashboards, visualizations; content research for bloggers, YouTubers, and podcasters.
- 🤝 **Non-profit & civic** — transparency reporting, advocacy backed by public-interest data, community databases.
- 🧪 **Experimentation** — prototype AI/ML pipelines on real data; validate product hypotheses before engineering spend.

***

### 🔌 Automating USGS Seismic Risk Profiler

Control this Actor programmatically for scheduled runs and pipelines:

**Node.js** (`apify-client` on NPM):

```javascript
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('saint_person/usgs-seismic-risk-profiler').call({
  "latitude": 40.7128,
  "longitude": -74.0060,
  "radiusKm": 100,
  "daysBack": 30
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client` on PyPI):

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('saint_person/usgs-seismic-risk-profiler').call(run_input={
  "latitude": 40.7128,
  "longitude": -74.0060,
  "radiusKm": 100,
  "daysBack": 30
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

📚 [Full Apify API documentation](https://docs.apify.com/api/v2)

[Apify Schedules](https://docs.apify.com/platform/schedules) triggers this Actor on any cron interval — hourly for fresh monitoring, daily for feeds, weekly for historical datasets.

***

### 🧠 Use via MCP (for AI agents)

USGS Seismic Risk Profiler is directly callable by any MCP-compatible AI agent (Claude, ChatGPT, Cursor, and others) through Apify's hosted MCP server — no custom integration code needed.

Add this to your MCP client config (e.g. Claude Desktop's `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/sse?actors=saint_person/usgs-seismic-risk-profiler",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Once connected, just ask your agent something like: *"Use the USGS Seismic Risk Profiler Actor to pull location risk assessment data for my target and summarize it."* The agent reads the input schema automatically and calls the Actor directly — no manual dataset download step.

📚 [Apify MCP server docs](https://docs.apify.com/platform/integrations/mcp)

***

### 🤖 Ask an AI assistant about this Actor

Open a ready-to-send prompt in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20USGS%20Seismic%20Risk%20Profiler%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20USGS%20Seismic%20Risk%20Profiler%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20USGS%20Seismic%20Risk%20Profiler%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter latitude/longitude, click Start. The Actor queries the official USGS Earthquake Hazards Program API, retrieves recent seismic activity within your radius, calculates distance from your location, and returns risk classifications plus magnitude data.

#### 🔐 Do I need a USGS account or API key?

No - the Actor works out of the box. USGS Earthquake API is public and requires no authentication.

#### ⚠️ How is risk level calculated?

Risk is scored by earthquake magnitude + distance from your target location. Magnitude > 5 = HIGH; 4-5 = MODERATE; < 4 = LOW. Earthquakes > 50 km away default to LOW regardless of magnitude.

#### 🌍 Does this work outside the continental US?

The USGS Earthquake Hazards API covers the US and territories. For global earthquake data, use USGS's comprehensive GeoJSON endpoints.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly).

#### ⚖️ Is this data legal to collect?

This Actor only collects data that is publicly accessible through the official USGS Earthquake Hazards Program API, a public service. No login, no bypass of access controls. You are responsible for complying with the source's Terms of Service and any regulations that apply to your use.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan is enough for testing and small runs. Paid plans unlock larger runs, scheduling, and higher concurrency.

#### 🔁 What happens if a run fails?

Transient errors retry automatically with backoff. If a run still fails, the log explains exactly why, and partial results are preserved — you never lose progress.

#### 🆘 What if I need help?

Open an issue on this Actor's Issues tab — reliability is the whole point, and issues get fixed with priority. You can also request custom features or entirely new Actors there.

***

### 🔌 Integrate with any app

USGS Seismic Risk Profiler connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) — connect with 5,000+ apps
- [**Make**](https://docs.apify.com/platform/integrations/make) — automate multi-step workflows
- [**n8n**](https://docs.apify.com/platform/integrations) — self-hosted automation
- [**Google Sheets**](https://docs.apify.com/platform/integrations/drive) — export datasets to a shared sheet
- [**Slack**](https://docs.apify.com/platform/integrations/slack) — run notifications in your channels
- [**Gmail**](https://docs.apify.com/platform/integrations/gmail) — email results automatically after each run
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) — trigger downstream pipelines
- [**MCP**](https://docs.apify.com/platform/integrations/mcp) — let AI agents call this Actor directly

***

### 🧩 Works even better together

Pair this Actor with your property analysis or insurance pipeline: run the seismic assessment here, then feed risk scores into pricing models or underwriting automation. *(Backfill with companion Actors once available.)*

***

### 🔗 Recommended Actors

- *(Coming soon: additional risk assessment actors and location-intelligence tools.)*

> 💡 **Pro tip:** browse the complete [ParseForge collection](https://apify.com/saint_person) for more tools like this.

***

### 🆘 Help & custom requests

- 🐛 **Something not working?** Open an issue on this Actor's **Issues tab** — reliability is the whole point, and issues are fixed with priority.
- 🛠️ **Need a custom feature, a different data source, or an entirely new Actor built for you?** Open an issue describing what you need — custom builds are available.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by USGS - U.S. Geological Survey. All trademarks are the property of their respective owners. Only publicly available data is collected.

# Actor input Schema

## `latitude` (type: `number`):

Latitude of the location to assess for seismic risk. Example: 40.7128 for New York.

## `longitude` (type: `number`):

Longitude of the location. Example: -74.0060 for New York.

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

Radius in kilometers to search for recent earthquakes. Default 100 km.

## `daysBack` (type: `integer`):

How many days back to analyze earthquake data. Default 30 days.

## Actor input object example

```json
{
  "latitude": 40.7128,
  "longitude": -74.006,
  "radiusKm": 100,
  "daysBack": 30
}
```

# 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 = {
    "latitude": 40.7128,
    "longitude": -74.006,
    "radiusKm": 100,
    "daysBack": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("saint_person/usgs-seismic-risk-profiler").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 = {
    "latitude": 40.7128,
    "longitude": -74.006,
    "radiusKm": 100,
    "daysBack": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("saint_person/usgs-seismic-risk-profiler").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 '{
  "latitude": 40.7128,
  "longitude": -74.006,
  "radiusKm": 100,
  "daysBack": 30
}' |
apify call saint_person/usgs-seismic-risk-profiler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=saint_person/usgs-seismic-risk-profiler",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Seismic Risk Profiler (Official API)",
        "description": "Analyze earthquake risk and geological hazards for any US location using official USGS data. Stable API, no auth required.",
        "version": "1.0",
        "x-build-id": "Wa3t0Up2v4vZ9w2jX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/saint_person~usgs-seismic-risk-profiler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-saint_person-usgs-seismic-risk-profiler",
                "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/saint_person~usgs-seismic-risk-profiler/runs": {
            "post": {
                "operationId": "runs-sync-saint_person-usgs-seismic-risk-profiler",
                "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/saint_person~usgs-seismic-risk-profiler/run-sync": {
            "post": {
                "operationId": "run-sync-saint_person-usgs-seismic-risk-profiler",
                "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": [
                    "latitude",
                    "longitude"
                ],
                "properties": {
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Latitude of the location to assess for seismic risk. Example: 40.7128 for New York."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Longitude of the location. Example: -74.0060 for New York."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Radius in kilometers to search for recent earthquakes. Default 100 km.",
                        "default": 100
                    },
                    "daysBack": {
                        "title": "Historical range (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How many days back to analyze earthquake data. Default 30 days.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
