> ## Documentation Index
> Fetch the complete documentation index at: https://docs.terraquakeapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# GET v1/stations/status/open

> Retrieve all currently operational seismic monitoring stations

## Endpoint

```
GET https://api.terraquakeapi.com/v1/stations/status/open
```

## Description

Retrieves only the stations that are currently operational (status: "open"). These are stations actively collecting and transmitting seismic data in real-time. This endpoint filters the complete INGV network to return only functional, active monitoring stations.

Ideal for applications that need to work with live data sources or ensure station availability before integration.

## Use Cases

* **Real-Time Monitoring**: Identify which stations are providing current data
* **Network Health**: Monitor the operational status of the seismic network
* **Data Quality**: Ensure you're working with active data sources
* **Coverage Analysis**: Assess geographic coverage of active monitoring
* **Integration Planning**: Determine available stations for data feeds

## Parameters

**limit** `integer` (default: 50)

Number of stations to return per page. Must be a positive integer greater than
0\. **Maximum**: 1000 **Example**: `?limit=100`

**page** `integer` (default: 1)

Page number for pagination. Must be a positive integer greater than 0.
**Example**: `?page=2`

## Request Examples

```bash cURL theme={null}
curl "https://api.terraquakeapi.com/v1/stations/status/open?limit=100&page=1"
```

```javascript JavaScript theme={null}
const response = await fetch(
  'https://api.terraquakeapi.com/v1/stations/status/open?limit=100',
);
const data = await response.json();

if (data.success) {
  console.log(`Total active stations: ${data.totalStationsOpen}`);
  console.log(
    `Retrieved ${data.payload.length} stations on page ${data.pagination.page}`,
  );

  // Map active station codes
  const activeCodes = data.payload.map((station) => station.$.code);
  console.log('Active station codes:', activeCodes);

  // Find stations by region
  const sicilianStations = data.payload.filter(
    (station) =>
      station.Site.Name.includes('(CT)') ||
      station.Site.Name.includes('(RG)') ||
      station.Site.Name.includes('(ME)'),
  );
  console.log(`Active Sicilian stations: ${sicilianStations.length}`);
}
```

```python Python theme={null}
import requests

url = "https://api.terraquakeapi.com/v1/stations/status/open"
params = {"limit": 100, "page": 1}

response = requests.get(url, params=params)
data = response.json()

if data.get('success'):
    print(f"Total active stations: {data.get('totalStationsOpen')}")

    # Group by region (from site name)
    regions = {}
    for station in data.get('payload', []):
        site = station.get('Site', {}).get('Name', '')
        # Extract region code from parentheses
        if '(' in site:
            region = site.split('(')[-1].strip(')')
            regions[region] = regions.get(region, 0) + 1

    print("\nActive stations by region:")
    for region, count in sorted(regions.items()):
        print(f"{region}: {count}")
```

```php PHP theme={null}
<?php
$url = "https://api.terraquakeapi.com/v1/stations/status/open?limit=100";
$response = file_get_contents($url);
$data = json_decode($response, true);

if ($data['success']) {
    echo "Total active stations: " . $data['totalStationsOpen'] . "\n\n";

    foreach ($data['payload'] as $station) {
        $code = $station['$']['code'];
        $name = $station['Site']['Name'];
        $lat = $station['Latitude'];
        $lon = $station['Longitude'];

        echo "$code - $name ($lat, $lon)\n";
    }
}
?>
```

## Response Format

**success** `boolean`

Indicates if the request was successful

**code** `integer`

HTTP status code (200 for success)

**status** `string`

HTTP status message

**message** `string`

Human-readable description ("List of active seismic stations")

**payload** `array`

Array of active station objects (see Station Object structure)

**totalStationsOpen** `integer`

Total number of currently operational stations

**pagination** `object`

Pagination metadata

**page** `integer`

Current page number

**totalPages** `integer`

Total number of pages available

**limit** `integer`

Number of results per page

**hasMore** `boolean`

Whether more pages are available

**meta** `object`

Request metadata (method, path, timestamp)

## Station Object Structure

Each station object has the following structure:

**\$** `object`

Station metadata attributes

**code** `string`

Unique station code

**name** `string`

Full station name with network prefix

**restrictedStatus** `string`

Always "open" for this endpoint

**startDate** `string`

ISO 8601 date when the station became operational

**Latitude** `float`

Station latitude in decimal degrees

**Longitude** `float`

Station longitude in decimal degrees

**Elevation** `float`

Station elevation in meters above sea level

**Site** `object`

**Name** `string`

Human-readable site location name

**CreationDate** `string`

ISO 8601 timestamp when the station record was created

## Response Example

```json theme={null}
{
  "success": true,
  "code": 200,
  "status": "OK",
  "message": "List of active seismic stations",
  "payload": [
    {
      "$": {
        "code": "ACATE",
        "name": "IV.ACATE",
        "restrictedStatus": "open",
        "startDate": "2015-06-10T00:00:00"
      },
      "Latitude": 37.0287,
      "Longitude": 14.4983,
      "Elevation": 206.0,
      "Site": {
        "Name": "Acate (RG)"
      },
      "CreationDate": "2015-06-10T00:00:00"
    },
    {
      "$": {
        "code": "ACER",
        "name": "IV.ACER",
        "restrictedStatus": "open",
        "startDate": "2009-03-12T00:00:00"
      },
      "Latitude": 40.7328,
      "Longitude": 15.9428,
      "Elevation": 652.0,
      "Site": {
        "Name": "Acerenza (PZ)"
      },
      "CreationDate": "2009-03-12T00:00:00"
    }
  ],
  "meta": {
    "method": "GET",
    "path": "/v1/stations/status/open?limit=2&page=1",
    "timestamp": "2025-11-06T11:30:45.680Z"
  },
  "totalStationsOpen": 385,
  "pagination": {
    "page": 1,
    "totalPages": 193,
    "limit": 2,
    "hasMore": true
  }
}
```

## Error Responses

### Invalid Parameters

```json theme={null}
{
  "success": false,
  "code": 400,
  "status": "Bad Request",
  "message": "The 'limit' parameter must be a positive integer greater than 0. Example: ?limit=50"
}
```

### No Open Stations Found

```json theme={null}
{
  "success": false,
  "code": 404,
  "status": "Not Found",
  "message": "No station found restrictedStatus open"
}
```

## Practical Examples

### Check Network Coverage

```javascript theme={null}
async function analyzeNetworkCoverage() {
  const response = await fetch(
    'https://api.terraquakeapi.com/v1/stations/status/open?limit=500',
  );
  const data = await response.json();

  if (data.success) {
    const stations = data.payload;

    // Calculate bounding box
    const lats = stations.map((s) => s.Latitude);
    const lons = stations.map((s) => s.Longitude);

    const bounds = {
      north: Math.max(...lats),
      south: Math.min(...lats),
      east: Math.max(...lons),
      west: Math.min(...lons),
    };

    console.log('Active network coverage:');
    console.log(
      `Latitude: ${bounds.south.toFixed(2)}° to ${bounds.north.toFixed(2)}°`,
    );
    console.log(
      `Longitude: ${bounds.west.toFixed(2)}° to ${bounds.east.toFixed(2)}°`,
    );
    console.log(`Total active stations: ${data.totalStationsOpen}`);
  }
}
```

### Export Active Stations to CSV

```python theme={null}
import requests
import csv

url = "https://api.terraquakeapi.com/v1/stations/status/open"
params = {"limit": 500}

response = requests.get(url, params=params)
data = response.json()

if data.get('success'):
    with open('active_stations.csv', 'w', newline='') as csvfile:
        fieldnames = ['code', 'name', 'latitude', 'longitude', 'elevation', 'site']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

        writer.writeheader()
        for station in data['payload']:
            writer.writerow({
                'code': station['$']['code'],
                'name': station['$']['name'],
                'latitude': station['Latitude'],
                'longitude': station['Longitude'],
                'elevation': station['Elevation'],
                'site': station['Site']['Name']
            })

    print(f"Exported {len(data['payload'])} active stations to active_stations.csv")
```

### Filter by Elevation Range

```javascript theme={null}
// Find high-altitude active stations
const response = await fetch(
  'https://api.terraquakeapi.com/v1/stations/status/open?limit=500',
);
const data = await response.json();

if (data.success) {
  const highAltitudeStations = data.payload.filter(
    (station) => station.Elevation > 1000,
  );

  console.log(
    `High-altitude stations (>1000m): ${highAltitudeStations.length}`,
  );

  highAltitudeStations.forEach((station) => {
    console.log(
      `${station.$.code}: ${station.Elevation}m - ${station.Site.Name}`,
    );
  });
}
```

## Station Status Definitions

This endpoint returns only stations with `restrictedStatus: "open"`, which means:

* Station is currently operational
* Actively collecting seismic data
* Transmitting data to INGV network
* Available for real-time monitoring
* No `endDate` specified

## Related Endpoints

> **[Closed Stations](https://docs.terraquakeapi.com/api/stations/status-closed.md)**
>
> Get inactive/historical stations

> **[Statistics](https://docs.terraquakeapi.com/api/stations/statistics.md)**
>
> View open vs closed station counts

> **[GeoJSON Format](https://docs.terraquakeapi.com/api/stations/geojson.md)**
>
> Map active stations

> **[Get All Stations](https://docs.terraquakeapi.com/api/stations/get-all.md)**
>
> Browse all stations (open and closed)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.