# FDSN Seismic Extractor (`datamule/fdsn-seismic-extractor`) Actor

Point at ANY seismic data center (USGS, INGV, GEOFON, IRIS, GeoNet…) and pull earthquakes or station metadata via the uniform FDSN web-services API. Query one center, a list, or all via the fdsn.org registry. Flat rows + lossless raw. Pay per record.

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

## Pricing

from $0.35 / 1,000 records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## FDSN Seismic Extractor

Point this Actor at **any seismic data center** and pull earthquakes or station metadata out through the **[FDSN web services](https://www.fdsn.org/webservices/) standard** — no per-center scraper. Every seismic data center on Earth (USGS, INGV, GEOFON, EarthScope/IRIS, SCEDC, NCEDC, GeoNet, EMSC, ISC, AusPass, and more) exposes the identical `/fdsnws/event/1/query` and `/fdsnws/station/1/query` endpoints, and the official [fdsn.org datacenter registry](https://www.fdsn.org/datacenters/) self-describes all 31 of them — so one Actor covers the whole federation.

### Three modes, chosen automatically from your input

#### 1. Discovery — map the federation
Leave **Data center** and **Service URL** empty (or turn on *List data centers only*) and the Actor maps the fdsn.org registry — **one row per (data center, service)** with the center's full name, website, and live `event`/`station` service URL. Use it first to discover valid center names.

```json
{ "listCentersOnly": true }
````

#### 2. Event — query earthquakes

Set **Data center** to a name (`USGS`), a comma-list (`INGV,GEOFON,EMSC`), or `all`, add the standard FDSN parameters, and the Actor returns one flat row per event plus a lossless `_raw` object.

```json
{ "dataService": "event", "center": "USGS", "starttime": "2024-01-01", "endtime": "2024-01-03", "minMagnitude": "5" }
```

#### 3. Station — query network / station / channel metadata

Switch **Data service** to `station`, choose a `level`, and filter by network / station / channel codes or a geographic area.

```json
{ "dataService": "station", "center": "IRIS", "network": "IU", "station": "ANMO", "level": "channel" }
```

### How it stays generic

The FDSN `text` format is uniform across centers, but a few rename or reorder columns (SCEDC ships a `Longtitude` typo and slash-dates; station columns differ by `level`). The Actor parses each response's `#` header **column by column**, so every center is read correctly and **every original column is preserved verbatim in `_raw`**. Events can optionally be fetched as **GeoJSON** (richer per-event properties from centers like USGS and INGV).

### Input

| Field | Description |
| --- | --- |
| `dataService` | `event` (earthquakes) or `station` (metadata). Default `event`. |
| `center` | Data center name(s) from the fdsn.org registry — one, a comma-list, or `all`. Common aliases work (`iris`, `usgs`, `ingv`, `geofon`…). Leave empty for discovery. |
| `serviceUrl` | Advanced: point directly at a center's FDSN endpoint (or bare host) and bypass the registry. |
| `listCentersOnly` | Discovery-only switch — map the registry without querying. |
| `level` | Station service only: `network`, `station`, `channel`, or `response`. |
| `format` | Event output: `text` (uniform) or `geojson` (richer). Station is always `text`. |
| `starttime` / `endtime` | Time window (ISO 8601). A bare date is expanded to `T00:00:00`. |
| `minMagnitude` / `maxMagnitude` | Magnitude bounds (event). |
| `minLatitude` / `maxLatitude` / `minLongitude` / `maxLongitude` | Bounding-box search. |
| `latitude` / `longitude` / `maxRadius` / `minRadius` | Radial search. |
| `minDepth` / `maxDepth` | Depth bounds in km (event). |
| `network` / `station` / `location` / `channel` | Code filters (station); comma-lists and `*` `?` wildcards supported. |
| `orderBy` | Event sort order (`time`, `magnitude`, …). |
| `maxRecords` | Max total records across all queried centers (default 1000). Each record is one billable event. |
| `extraParams` | Any additional FDSN query parameters as a JSON object, passed straight through. |
| `bearerToken` / `extraHeaders` | Optional auth for gated deployments. Never logged. |

### Output

Every record shares a stable, fully-declared set of fields — `_dataService`, `_center`, `_serviceUrl`, `_level`, `_rowIndex` — plus mode-specific data and a lossless `_raw`:

- **Event** records carry `eventId`, `time`, `latitude`, `longitude`, `depthKm`, `magnitude`, `magType`, `magAuthor`, `author`, `catalog`, `eventLocationName`, `eventType`.
- **Station** records carry `network`, `station`, `location`, `channel`, `siteName`, `elevation`, `depth`, `azimuth`, `dip`, `sensorDescription`, `scale`, `sampleRate`, `startTime`, `endTime` (fields populated depend on `level`).
- **Discovery** rows carry `serviceType`, `centerFullName`, `centerWebsite`, `centerSummary` and the service URL.

### Pricing

Pay-per-event: **one `record` charge per emitted row** (an event, a station/channel, or a discovery row). You pay only for what you extract.

### Notes

- A query that matches nothing (HTTP 204, or a header-only body) returns 0 records and exits cleanly — the Actor never fabricates rows.
- Parameters are **not** perfectly uniform across centers: GeoNet rejects `limit`; some centers want a full ISO datetime. The Actor normalizes bare dates and, in multi-center mode, **skips a center that rejects the query** (surfacing its own error) so one strict center never fails the whole run.
- Binary waveform data (`dataselect` / miniSEED) is intentionally **out of scope** — this Actor returns event and station *metadata* only.
- Public centers need no credentials. `bearerToken` / `extraHeaders` cover key-gated deployments and are never logged.

# Actor input Schema

## `dataService` (type: `string`):

Which FDSN web service to query: event (earthquakes / seismic events) or station (network / station / channel metadata). Both speak the identical FDSN grammar on every data center.

## `center` (type: `string`):

Which seismic data center(s) to query, by name from the fdsn.org registry (case-insensitive; common aliases work — iris, usgs, ingv, geofon, geonet, scedc, ncedc, emsc, isc, auspass…). One name (USGS), a comma-separated list (INGV,GEOFON,EMSC), or all to query every center that offers the chosen service. Leave EMPTY (and leave Service URL empty) to run discovery — list every center + its live service URL. For events, reliable centers include USGS, INGV, GEOFON, EMSC, ISC, GeoNet, SCEDC, NCEDC.

## `serviceUrl` (type: `string`):

Bypass the registry and point directly at a center's FDSN service — either a full endpoint (https://earthquake.usgs.gov/fdsnws/event/1/query, trailing /query optional) or a bare host (https://earthquake.usgs.gov), for which the standard /fdsnws/{service}/1/query path is built. Overrides Data center. Use this for a center not in the registry, or a private mirror.

## `listCentersOnly` (type: `boolean`):

When on, the actor ignores the query parameters and only maps the fdsn.org registry — one row per (data center, event|station service) with the center's full name, website and live service URL. This is also the default when both Data center and Service URL are empty. Use it first to discover valid center names, then set Data center to extract.

## `level` (type: `string`):

For the station service only: how much metadata to return — network, station, channel or response. More detail = more columns and more rows (one row per channel epoch at channel level). Ignored for the event service.

## `format` (type: `string`):

The wire format to request for the EVENT service: text (the uniform FDSN pipe-delimited format parsed on every center — recommended) or geojson (richer per-event properties from centers that support it, e.g. USGS and INGV). The station service is always fetched as text (no GeoJSON exists for it). QuakeML/StationXML are never requested — this actor returns flat rows.

## `starttime` (type: `string`):

FDSN start of the time window (ISO 8601). A bare date (2024-01-01) is expanded to 2024-01-01T00:00:00 automatically (several centers require the full form). For events this bounds origin time; for stations it bounds the metadata epoch.

## `endtime` (type: `string`):

FDSN end of the time window (ISO 8601). A bare date is expanded to T00:00:00. Keep the window modest for busy catalogs (a global M0+ event query can return millions of rows — combine with Min magnitude and Max records).

## `minMagnitude` (type: `string`):

Only return events at or above this magnitude. Strongly recommended on wide time windows to keep result counts (and cost) sane. Ignored by the station service.

## `maxMagnitude` (type: `string`):

Only return events at or below this magnitude (event service only).

## `minLatitude` (type: `string`):

Southern edge of a rectangular search area, degrees (-90..90). Combine min/max latitude + longitude for a bounding-box search. Works for both event and station.

## `maxLatitude` (type: `string`):

Northern edge of a rectangular search area, degrees (-90..90).

## `minLongitude` (type: `string`):

Western edge of a rectangular search area, degrees (-180..180).

## `maxLongitude` (type: `string`):

Eastern edge of a rectangular search area, degrees (-180..180).

## `latitude` (type: `string`):

Latitude of the center point for a radial search. Pair with Longitude + Max radius (and optional Min radius) instead of a bounding box.

## `longitude` (type: `string`):

Longitude of the center point for a radial search.

## `maxRadius` (type: `string`):

Maximum great-circle distance from the center point, in degrees, for a radial search.

## `minRadius` (type: `string`):

Minimum great-circle distance from the center point, in degrees (annular search).

## `minDepth` (type: `string`):

Only return events at or below this depth in kilometres (event service only).

## `maxDepth` (type: `string`):

Only return events at or above this depth in kilometres (event service only).

## `network` (type: `string`):

FDSN network code filter for the station service, e.g. IU, IV, NZ. Comma lists and wildcards (\* ?) are supported by most centers. Ignored for events.

## `station` (type: `string`):

Station code filter for the station service, e.g. ANMO. Comma lists and wildcards supported. Ignored for events.

## `location` (type: `string`):

Location code filter for the station service (e.g. 00, 10, or -- for blank). Ignored for events.

## `channel` (type: `string`):

Channel code filter for the station service, e.g. BHZ, HH?. Comma lists and wildcards supported. Ignored for events.

## `orderBy` (type: `string`):

Sort order for the event service — time, time-asc, magnitude or magnitude-asc (accepted values vary slightly by center). Ignored for stations.

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

Maximum total number of records to emit across all queried centers (events, stations or discovery rows). Each emitted record is one billable event. Default 25.

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

Any additional FDSN query parameters as a JSON object, passed straight through, e.g. {"includeallmagnitudes": "true", "eventtype": "earthquake"} for events or {"includerestricted": "false"} for stations. Explicit fields above take precedence. Note: some centers reject certain params (GeoNet rejects limit) and will return their own error.

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

Optional bearer token for a key-gated / restricted FDSN deployment. Sent as Authorization: Bearer \*\*\* — NOT needed for the public centers (USGS, INGV, GEOFON, IRIS, …). Never logged.

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

Optional extra HTTP headers to send with every request, as a JSON object, e.g. {"x-api-key": "..."} for a center behind an API gateway. Leave empty for the public centers.

## Actor input object example

```json
{
  "dataService": "event",
  "center": "USGS",
  "listCentersOnly": false,
  "level": "station",
  "format": "text",
  "starttime": "2024-01-01",
  "endtime": "2024-01-02",
  "minMagnitude": "5",
  "maxRecords": 25
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "center": "USGS",
    "starttime": "2024-01-01",
    "endtime": "2024-01-02",
    "minMagnitude": "5",
    "maxRecords": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/fdsn-seismic-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "center": "USGS",
    "starttime": "2024-01-01",
    "endtime": "2024-01-02",
    "minMagnitude": "5",
    "maxRecords": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("datamule/fdsn-seismic-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "center": "USGS",
  "starttime": "2024-01-01",
  "endtime": "2024-01-02",
  "minMagnitude": "5",
  "maxRecords": 25
}' |
apify call datamule/fdsn-seismic-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDSN Seismic Extractor",
        "description": "Point at ANY seismic data center (USGS, INGV, GEOFON, IRIS, GeoNet…) and pull earthquakes or station metadata via the uniform FDSN web-services API. Query one center, a list, or all via the fdsn.org registry. Flat rows + lossless raw. Pay per record.",
        "version": "0.1",
        "x-build-id": "Q3rAmfBTp8JvB2eKy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamule~fdsn-seismic-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamule-fdsn-seismic-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datamule~fdsn-seismic-extractor/runs": {
            "post": {
                "operationId": "runs-sync-datamule-fdsn-seismic-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datamule~fdsn-seismic-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-datamule-fdsn-seismic-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "dataService": {
                        "title": "Data service",
                        "enum": [
                            "event",
                            "station"
                        ],
                        "type": "string",
                        "description": "Which FDSN web service to query: event (earthquakes / seismic events) or station (network / station / channel metadata). Both speak the identical FDSN grammar on every data center.",
                        "default": "event"
                    },
                    "center": {
                        "title": "Data center(s)",
                        "type": "string",
                        "description": "Which seismic data center(s) to query, by name from the fdsn.org registry (case-insensitive; common aliases work — iris, usgs, ingv, geofon, geonet, scedc, ncedc, emsc, isc, auspass…). One name (USGS), a comma-separated list (INGV,GEOFON,EMSC), or all to query every center that offers the chosen service. Leave EMPTY (and leave Service URL empty) to run discovery — list every center + its live service URL. For events, reliable centers include USGS, INGV, GEOFON, EMSC, ISC, GeoNet, SCEDC, NCEDC."
                    },
                    "serviceUrl": {
                        "title": "Explicit service URL (advanced)",
                        "type": "string",
                        "description": "Bypass the registry and point directly at a center's FDSN service — either a full endpoint (https://earthquake.usgs.gov/fdsnws/event/1/query, trailing /query optional) or a bare host (https://earthquake.usgs.gov), for which the standard /fdsnws/{service}/1/query path is built. Overrides Data center. Use this for a center not in the registry, or a private mirror."
                    },
                    "listCentersOnly": {
                        "title": "List data centers only (discovery)",
                        "type": "boolean",
                        "description": "When on, the actor ignores the query parameters and only maps the fdsn.org registry — one row per (data center, event|station service) with the center's full name, website and live service URL. This is also the default when both Data center and Service URL are empty. Use it first to discover valid center names, then set Data center to extract.",
                        "default": false
                    },
                    "level": {
                        "title": "Station level (station service)",
                        "enum": [
                            "network",
                            "station",
                            "channel",
                            "response"
                        ],
                        "type": "string",
                        "description": "For the station service only: how much metadata to return — network, station, channel or response. More detail = more columns and more rows (one row per channel epoch at channel level). Ignored for the event service.",
                        "default": "station"
                    },
                    "format": {
                        "title": "Event output format",
                        "enum": [
                            "text",
                            "geojson"
                        ],
                        "type": "string",
                        "description": "The wire format to request for the EVENT service: text (the uniform FDSN pipe-delimited format parsed on every center — recommended) or geojson (richer per-event properties from centers that support it, e.g. USGS and INGV). The station service is always fetched as text (no GeoJSON exists for it). QuakeML/StationXML are never requested — this actor returns flat rows.",
                        "default": "text"
                    },
                    "starttime": {
                        "title": "Start time",
                        "type": "string",
                        "description": "FDSN start of the time window (ISO 8601). A bare date (2024-01-01) is expanded to 2024-01-01T00:00:00 automatically (several centers require the full form). For events this bounds origin time; for stations it bounds the metadata epoch."
                    },
                    "endtime": {
                        "title": "End time",
                        "type": "string",
                        "description": "FDSN end of the time window (ISO 8601). A bare date is expanded to T00:00:00. Keep the window modest for busy catalogs (a global M0+ event query can return millions of rows — combine with Min magnitude and Max records)."
                    },
                    "minMagnitude": {
                        "title": "Min magnitude (event)",
                        "type": "string",
                        "description": "Only return events at or above this magnitude. Strongly recommended on wide time windows to keep result counts (and cost) sane. Ignored by the station service."
                    },
                    "maxMagnitude": {
                        "title": "Max magnitude (event)",
                        "type": "string",
                        "description": "Only return events at or below this magnitude (event service only)."
                    },
                    "minLatitude": {
                        "title": "Min latitude (bounding box)",
                        "type": "string",
                        "description": "Southern edge of a rectangular search area, degrees (-90..90). Combine min/max latitude + longitude for a bounding-box search. Works for both event and station."
                    },
                    "maxLatitude": {
                        "title": "Max latitude (bounding box)",
                        "type": "string",
                        "description": "Northern edge of a rectangular search area, degrees (-90..90)."
                    },
                    "minLongitude": {
                        "title": "Min longitude (bounding box)",
                        "type": "string",
                        "description": "Western edge of a rectangular search area, degrees (-180..180)."
                    },
                    "maxLongitude": {
                        "title": "Max longitude (bounding box)",
                        "type": "string",
                        "description": "Eastern edge of a rectangular search area, degrees (-180..180)."
                    },
                    "latitude": {
                        "title": "Center latitude (radius search)",
                        "type": "string",
                        "description": "Latitude of the center point for a radial search. Pair with Longitude + Max radius (and optional Min radius) instead of a bounding box."
                    },
                    "longitude": {
                        "title": "Center longitude (radius search)",
                        "type": "string",
                        "description": "Longitude of the center point for a radial search."
                    },
                    "maxRadius": {
                        "title": "Max radius (degrees)",
                        "type": "string",
                        "description": "Maximum great-circle distance from the center point, in degrees, for a radial search."
                    },
                    "minRadius": {
                        "title": "Min radius (degrees)",
                        "type": "string",
                        "description": "Minimum great-circle distance from the center point, in degrees (annular search)."
                    },
                    "minDepth": {
                        "title": "Min depth (km, event)",
                        "type": "string",
                        "description": "Only return events at or below this depth in kilometres (event service only)."
                    },
                    "maxDepth": {
                        "title": "Max depth (km, event)",
                        "type": "string",
                        "description": "Only return events at or above this depth in kilometres (event service only)."
                    },
                    "network": {
                        "title": "Network code (station)",
                        "type": "string",
                        "description": "FDSN network code filter for the station service, e.g. IU, IV, NZ. Comma lists and wildcards (* ?) are supported by most centers. Ignored for events."
                    },
                    "station": {
                        "title": "Station code (station)",
                        "type": "string",
                        "description": "Station code filter for the station service, e.g. ANMO. Comma lists and wildcards supported. Ignored for events."
                    },
                    "location": {
                        "title": "Location code (station)",
                        "type": "string",
                        "description": "Location code filter for the station service (e.g. 00, 10, or -- for blank). Ignored for events."
                    },
                    "channel": {
                        "title": "Channel code (station)",
                        "type": "string",
                        "description": "Channel code filter for the station service, e.g. BHZ, HH?. Comma lists and wildcards supported. Ignored for events."
                    },
                    "orderBy": {
                        "title": "Order by (event)",
                        "type": "string",
                        "description": "Sort order for the event service — time, time-asc, magnitude or magnitude-asc (accepted values vary slightly by center). Ignored for stations."
                    },
                    "maxRecords": {
                        "title": "Max records (total)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total number of records to emit across all queried centers (events, stations or discovery rows). Each emitted record is one billable event. Default 25.",
                        "default": 25
                    },
                    "extraParams": {
                        "title": "Extra FDSN query params",
                        "type": "object",
                        "description": "Any additional FDSN query parameters as a JSON object, passed straight through, e.g. {\"includeallmagnitudes\": \"true\", \"eventtype\": \"earthquake\"} for events or {\"includerestricted\": \"false\"} for stations. Explicit fields above take precedence. Note: some centers reject certain params (GeoNet rejects limit) and will return their own error."
                    },
                    "bearerToken": {
                        "title": "Bearer token (optional)",
                        "type": "string",
                        "description": "Optional bearer token for a key-gated / restricted FDSN deployment. Sent as Authorization: Bearer *** — NOT needed for the public centers (USGS, INGV, GEOFON, IRIS, …). Never logged."
                    },
                    "extraHeaders": {
                        "title": "Extra request headers",
                        "type": "object",
                        "description": "Optional extra HTTP headers to send with every request, as a JSON object, e.g. {\"x-api-key\": \"...\"} for a center behind an API gateway. Leave empty for the public centers."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
