# Macrostrat Geology Units Scraper (`parseforge/macrostrat-geology-units-scraper`) Actor

Pull the full geologic column for any latitude and longitude from Macrostrat. Returns unit and formation names, top and bottom ages in millions of years, lithology, depositional environment, mapped thickness, and column id. Search by point or stratigraphic name for research and mapping.

- **URL**: https://apify.com/parseforge/macrostrat-geology-units-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🪨 Macrostrat Geology Units Scraper

> 🚀 **Export the full geologic column for any location in seconds.** Drop a latitude/longitude and pull back every stacked rock unit with names, ages, lithology and depositional environment, ready as CSV, Excel, JSON or XML.

> 🕒 **Last updated:** 2026-06-05 · **📊 23 fields** per record · point-and-column coverage · powered by the open Macrostrat database

Macrostrat is a community geologic database that stitches together stratigraphic columns from across North America and beyond. This Actor turns that database into clean, structured rows: give it a point on the map (or a stratigraphic name) and it returns every geologic unit in that column, from the youngest surface formation down to the deepest mapped layer, with absolute ages in millions of years (Ma), rock type, depositional environment, mapped thickness and the official display color.

**Coverage:** Any location served by the Macrostrat column model (dense coverage across the United States, with growing global columns). A single query near Madison, Wisconsin returns 15 units spanning roughly 458 to 1100+ million years, ideal for testing before scaling out.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Geologists, geoscience students, GIS analysts, data journalists, EdTech builders, environmental and resource consultants | Building geologic profiles, populating maps and dashboards, age dating a site, lithology lookups, teaching stratigraphy, enriching environmental reports |

### 📋 What the Macrostrat Geology Units Scraper does

- Accepts a **latitude/longitude** point and returns every geologic unit in the Macrostrat column at that location.
- Alternatively accepts a **stratigraphic name** (formation/group) to pull all matching units across columns.
- Extracts **unit and formation/group names**, **top and bottom ages in Ma**, **lithology**, **depositional environment**, **mapped thickness**, **column id and area**, **center coordinates** and the official **display color**.
- Outputs flat, analysis-ready rows. Download as CSV, Excel, JSON or XML, or pull via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Key | Type | Description |
|---|---|---|---|
| Latitude | `lat` | string | Latitude of the query point (decimal degrees, WGS84). |
| Longitude | `lng` | string | Longitude of the query point (decimal degrees, WGS84). |
| Stratigraphic name | `stratName` | string | Optional. Look up units by formation/group name instead of by location. When set, `lat`/`lng` are ignored. |
| Max Items | `maxItems` | integer | Free users limited to 10 (preview). Paid users up to 1,000,000. |

**Example 1 — by location (default, near Madison, WI):**
```json
{
    "lat": "43",
    "lng": "-89.3",
    "maxItems": 10
}
````

**Example 2 — by stratigraphic name:**

```json
{
    "stratName": "Mancos",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** A location query returns the units stacked in a single Macrostrat column, so most points return between 5 and 30 units. To map a wide region, run several points or use a stratigraphic name lookup. Ages are model estimates in millions of years (Ma) and `member` is only populated for units that carry a named member.

### 📊 Output

| Field | Key | Description |
|---|---|---|
| 📌 Unit | `unitName` | Mapped unit name (e.g. "St Peter Fm"). |
| 🪨 Formation | `formation` | Formation name, when assigned. |
| 🗂 Group | `group` | Group name, when assigned. |
| 🧩 Member | `member` | Member name (only for units with a named member). |
| 🏷 Strat name | `stratName` | Full stratigraphic name. |
| ⬆ Top age (Ma) | `topAgeMa` | Youngest age boundary in millions of years. |
| ⬇ Bottom age (Ma) | `bottomAgeMa` | Oldest age boundary in millions of years. |
| 🕰 Top interval | `topInterval` | Named geologic interval at the top. |
| 🕰 Bottom interval | `bottomInterval` | Named geologic interval at the bottom. |
| 🧱 Lithology | `lithology` | Rock types present in the unit. |
| 🌊 Environment | `depositionalEnvironment` | Depositional environment(s). |
| 🌄 Outcrop | `outcrop` | Outcrop status (surface, subsurface or both). |
| 📏 Max thickness (m) | `maxThicknessM` | Maximum mapped thickness in meters. |
| 📐 Min thickness (m) | `minThicknessM` | Minimum mapped thickness in meters. |
| 🎨 Color | `color` | Official display hex color. |
| 🆔 Unit id | `unitId` | Macrostrat unit identifier. |
| 🆔 Column id | `columnId` | Macrostrat column identifier. |
| 🆔 Section id | `sectionId` | Macrostrat section identifier. |
| 🗺 Column area (km²) | `columnAreaKm2` | Area of the column footprint. |
| 📍 Column lat | `columnLat` | Column center latitude. |
| 📍 Column lng | `columnLng` | Column center longitude. |
| 🔗 Source URL | `sourceUrl` | Macrostrat API request used. |
| 🕒 Scraped | `scrapedAt` | ISO timestamp of the run. |
| ❌ Error | `error` | Null on success, message on failure. |

**Real sample records:**

```json
[
  {
    "unitName": "St Peter Fm",
    "formation": "St Peter Sandstone",
    "group": null,
    "stratName": "St Peter Sandstone",
    "topAgeMa": 458.2,
    "bottomAgeMa": 459.186,
    "lithology": "quartz arenite",
    "depositionalEnvironment": "inferred marine",
    "outcrop": "both",
    "maxThicknessM": 35,
    "color": "#FCF768",
    "columnId": 187,
    "columnAreaKm2": 18140.93,
    "scrapedAt": "2026-06-05T15:56:13.407Z",
    "error": null
  },
  {
    "unitName": "Oneonta Fm",
    "formation": "Oneota",
    "group": "Prairie du Chien",
    "stratName": "Oneota Formation",
    "topAgeMa": 477.1,
    "bottomAgeMa": 486.85,
    "lithology": "dolomite, quartz arenite",
    "depositionalEnvironment": "inferred marine",
    "outcrop": "both",
    "maxThicknessM": 30,
    "color": "#4D52E7",
    "columnId": 187,
    "columnAreaKm2": 18140.93,
    "scrapedAt": "2026-06-05T15:56:13.500Z",
    "error": null
  },
  {
    "unitName": "Jordan Fm",
    "formation": "Jordan",
    "group": null,
    "stratName": "Jordan Formation",
    "topAgeMa": 486.85,
    "bottomAgeMa": 488.2625,
    "lithology": "quartz arenite",
    "depositionalEnvironment": "marine",
    "outcrop": "both",
    "maxThicknessM": 15,
    "color": "#FCF768",
    "columnId": 187,
    "columnAreaKm2": 18140.93,
    "scrapedAt": "2026-06-05T15:56:13.526Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- **Real ages, not labels.** Every unit ships absolute top and bottom ages in Ma, not just period names.
- **Clean, flat rows.** Nested lithology and environment arrays are flattened into readable text fields.
- **Two query modes.** Search by map point or by stratigraphic name, no GIS software required.
- **No keys, no friction.** Built on the open Macrostrat API, so there is nothing to register or rotate.
- **Export anywhere.** CSV, Excel, JSON, XML or API in one click.

### 📈 How it compares to alternatives

| Approach | Setup | Ages in Ma | Flat export | Point lookup |
|---|---|---|---|---|
| This Actor | None | Yes | Yes (CSV/Excel/JSON/XML) | Yes |
| Raw Macrostrat API | Manual JSON parsing | Yes | No (nested JSON) | Yes |
| Desktop GIS + geology layers | Heavy install | Sometimes | Manual | Yes |
| Static PDF geologic maps | None | Rarely | No | No |

### 🚀 How to use

1. **Sign up** for a free Apify account with this [referral link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the **Macrostrat Geology Units Scraper** and go to the input tab.
3. Enter a **latitude** and **longitude** (or a **stratigraphic name**) and set **Max Items**.
4. Click **Start** and watch the geologic column fill in.
5. **Download** your dataset as CSV, Excel, JSON or XML, or grab it via the API.

### 💼 Business use cases

#### 🏗 Environmental & resource consulting

| Need | How this helps |
|---|---|
| Site characterization | Pull the full geologic column under a project location in one query. |
| Desktop study reports | Drop ages, lithology and thickness straight into deliverables. |

#### 🎓 EdTech & research

| Need | How this helps |
|---|---|
| Teaching stratigraphy | Generate ready-made column datasets for any classroom location. |
| Comparative studies | Batch many points to compare geologic histories across regions. |

#### 🗺 Mapping & GIS

| Need | How this helps |
|---|---|
| Map enrichment | Join units to coordinates and official display colors. |
| Dashboards | Feed age and lithology fields into BI tools. |

#### 📰 Data journalism

| Need | How this helps |
|---|---|
| Explainers | Back stories about deep time with sourced, structured ages. |
| Visualizations | Export clean rows for charting geologic timelines. |

### 🔌 Automating Macrostrat Geology Units Scraper

Connect runs and datasets to the tools you already use:

- **Make** and **Zapier** — trigger runs and route new rows on a schedule.
- **Slack** — post a summary of new units to a channel.
- **Airbyte** — sync datasets into your warehouse.
- **GitHub Actions** — kick off scheduled runs from your pipelines.
- **Google Drive** — drop exports into a shared folder automatically.

### 🌟 Beyond business use cases

- **Research:** assemble reproducible geologic datasets for papers and theses.
- **Personal:** learn the deep history beneath your home town.
- **Non-profit:** support conservation and hazard-awareness projects with open geology.
- **Experimentation:** prototype geoscience apps and visualizations quickly.

### 🤖 Ask an AI assistant

Paste your exported rows into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai) or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize the geologic history, build a timeline, or explain the lithologies in plain language.

### ❓ Frequently Asked Questions

**Q: Do I need a Macrostrat API key?**
No. Macrostrat's API is open and keyless, so the Actor works out of the box.

**Q: How many units does a location return?**
A single column typically returns 5 to 30 units. The default Madison, WI point returns 15.

**Q: What do the ages mean?**
`topAgeMa` and `bottomAgeMa` are the youngest and oldest age boundaries of the unit in millions of years before present.

**Q: Can I search by formation name instead of coordinates?**
Yes. Set `stratName` (e.g. "Mancos") and the location fields are ignored.

**Q: Why is `member` sometimes empty?**
Only units that carry a named member populate it. It is left null otherwise rather than filled with a placeholder.

**Q: What export formats are supported?**
CSV, Excel, JSON, XML and the Apify API.

**Q: How fresh is the data?**
It is pulled live from Macrostrat at run time, so it reflects the current database.

**Q: Does it cover areas outside the United States?**
Macrostrat has dense US coverage and a growing set of global columns. Points without a column return no units.

**Q: Can I run many locations at once?**
Run the Actor once per point, or schedule a series of runs through Make, Zapier or the API.

**Q: Is this affiliated with Macrostrat?**
No. It is an independent tool that reads only publicly available Macrostrat data.

### 🔌 Integrate with any app

Every run produces a standard Apify dataset, so you can pull results through the [Apify API](https://docs.apify.com/api/v2), webhooks, or any of the 5,000+ apps reachable through Make and Zapier.

### 🔗 Recommended Actors

Browse more open-data and research scrapers in the [ParseForge collection](https://apify.com/parseforge) — including geospatial, scientific and public-records tools that pair well with geologic data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Macrostrat. Only publicly available data collected.

# Actor input Schema

## `lat` (type: `string`):

Latitude of the location to query (decimal degrees, WGS84). Returns all geologic units in the Macrostrat column at this point.

## `lng` (type: `string`):

Longitude of the location to query (decimal degrees, WGS84).

## `stratName` (type: `string`):

Optional. Look up units by formation/group name (e.g. 'Mancos', 'St Peter') instead of by location. When set, lat/lng are ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "lat": "43",
  "lng": "-89.3",
  "maxItems": 10
}
```

# 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 = {
    "lat": "43",
    "lng": "-89.3",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/macrostrat-geology-units-scraper").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 = {
    "lat": "43",
    "lng": "-89.3",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/macrostrat-geology-units-scraper").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 '{
  "lat": "43",
  "lng": "-89.3",
  "maxItems": 10
}' |
apify call parseforge/macrostrat-geology-units-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/macrostrat-geology-units-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Macrostrat Geology Units Scraper",
        "description": "Pull the full geologic column for any latitude and longitude from Macrostrat. Returns unit and formation names, top and bottom ages in millions of years, lithology, depositional environment, mapped thickness, and column id. Search by point or stratigraphic name for research and mapping.",
        "version": "0.1",
        "x-build-id": "H8jB5dRAPyMeKm0KC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~macrostrat-geology-units-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-macrostrat-geology-units-scraper",
                "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/parseforge~macrostrat-geology-units-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-macrostrat-geology-units-scraper",
                "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/parseforge~macrostrat-geology-units-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-macrostrat-geology-units-scraper",
                "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": {
                    "lat": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Latitude of the location to query (decimal degrees, WGS84). Returns all geologic units in the Macrostrat column at this point."
                    },
                    "lng": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Longitude of the location to query (decimal degrees, WGS84)."
                    },
                    "stratName": {
                        "title": "Stratigraphic name (optional)",
                        "type": "string",
                        "description": "Optional. Look up units by formation/group name (e.g. 'Mancos', 'St Peter') instead of by location. When set, lat/lng are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
