# ISS & Satellite Live Position Scraper (`parseforge/iss-current-location-scraper`) Actor

Track the International Space Station and any NORAD-cataloged satellite in real time. Pull live latitude, longitude, altitude, velocity, footprint, and visibility. Snapshot once or stream multiple positions over time for path mapping.

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

## Pricing

from $10.00 / 1,000 result items

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)

## 🛰️ ISS Live Position Scraper

> 🚀 **Track the International Space Station in real time.** Pull **live latitude, longitude, altitude, velocity, footprint, and visibility** for NORAD 25544 in one call, or stream multiple snapshots for orbit-path mapping. No API key, no registration, no manual JSON wrangling.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per snapshot · **🛰️ NORAD 25544** · **🌍 worldwide footprint** · **⏱️ second-level precision**

The **ISS Live Position Scraper** queries the where-the-ISS-at live position feed and returns **14 structured fields per snapshot**, including the satellite's instantaneous geodetic coordinates, altitude above the WGS-84 ellipsoid, ground velocity, footprint diameter, and a day/night visibility flag derived from the current solar geometry. The underlying source has tracked the ISS continuously since 2014 and is the most widely cited public position feed for the station.

The output covers **every orbit, every continent, every day-night transition**, and works for any moment from "now" forward in time. Snapshot once for a quick "where is it?" lookup, or stream up to 1,000 snapshots per run to draw a flight path. This Actor delivers the data as CSV, Excel, JSON, or XML in seconds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Space-education platforms, ISS-tracker apps, astronomy clubs, science museums, STEM teachers, hobbyist developers | Live position dashboards, pass-prediction inputs, classroom demos, orbit-path mapping, sky-watch alerts, museum exhibits |

---

### 📋 What the ISS Live Position Scraper does

Three workflows in a single run:

- 📍 **Single-point snapshot.** One live reading, perfect for a "where is the ISS right now?" widget.
- 🌐 **Multi-snapshot stream.** Up to 1,000 sequential readings with a configurable delay, for plotting a path on a map.
- 📐 **Unit switch.** Choose kilometers/km/h or miles/mph for altitude, velocity, and footprint.

Each snapshot includes the NORAD ID, satellite name, exact UTC timestamp, latitude, longitude, altitude, velocity, visibility (`daylight` / `eclipsed`), ground-footprint diameter, Julian day number, solar sub-point coordinates, and the unit system in use.

> 💡 **Why it matters:** accurate live position data underpins every ISS tracker, pass-prediction widget, classroom dashboard, and amateur radio sked. Polling the source yourself means rate-limit handling, JSON parsing, and unit conversion. This Actor handles all of it and emits clean rows.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a streamed flight path._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>satelliteIds</code></td><td>string[]</td><td><code>["25544"]</code></td><td>List of NORAD catalog numbers. The live feed currently tracks the ISS (25544); other IDs return a per-item explanatory message.</td></tr>
<tr><td><code>units</code></td><td>string</td><td><code>"kilometers"</code></td><td><code>kilometers</code> or <code>miles</code>.</td></tr>
<tr><td><code>snapshotsPerSatellite</code></td><td>integer</td><td><code>1</code></td><td>Number of sequential snapshots per satellite (1-1000).</td></tr>
<tr><td><code>delayBetweenChecksMs</code></td><td>integer</td><td><code>5000</code></td><td>Delay between snapshots in milliseconds. Minimum 1000.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return across all satellites and snapshots.</td></tr>
</tbody>
</table>

**Example: single live snapshot of the ISS in metric units.**

```json
{
    "satelliteIds": ["25544"],
    "units": "kilometers",
    "snapshotsPerSatellite": 1
}
````

**Example: 60 snapshots, 10 seconds apart, for a 10-minute orbit trail.**

```json
{
    "satelliteIds": ["25544"],
    "units": "kilometers",
    "snapshotsPerSatellite": 60,
    "delayBetweenChecksMs": 10000,
    "maxItems": 60
}
```

> ⚠️ **Good to Know:** the position feed is updated in near real time but represents a propagated state vector, not a hardware telemetry stream. For sub-second-precision applications (radio communication, optical tracking), compute the position yourself from current TLEs.

***

### 📊 Output

Each position snapshot contains **14 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `satelliteId` | number | `25544` |
| 🛰️ `name` | string | `"iss"` |
| 🕒 `timestampUtc` | ISO 8601 | `"2026-05-22T18:42:11.000Z"` |
| 📍 `latitude` | number | `-12.456` |
| 📍 `longitude` | number | `78.901` |
| ⛰️ `altitude` | number | `421.5` |
| 💨 `velocity` | number | `27582.4` |
| 🌗 `visibility` | string | `"daylight"` |
| 📐 `footprint` | number | `4538.1` |
| 📅 `daynum` | number | `2461185.279` |
| ☀️ `solarLatitude` | number | `20.13` |
| ☀️ `solarLongitude` | number | `-92.45` |
| 📏 `units` | string | `"kilometers"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T18:42:11.123Z"` |

#### 📦 Sample records

<details>
<summary><strong>🛰️ Single live snapshot (metric)</strong></summary>

```json
{
    "satelliteId": 25544,
    "name": "iss",
    "timestampUtc": "2026-05-22T18:42:11.000Z",
    "latitude": -12.456,
    "longitude": 78.901,
    "altitude": 421.5,
    "velocity": 27582.4,
    "visibility": "daylight",
    "footprint": 4538.1,
    "daynum": 2461185.279,
    "solarLatitude": 20.13,
    "solarLongitude": -92.45,
    "units": "kilometers",
    "scrapedAt": "2026-05-22T18:42:11.123Z"
}
```

</details>

<details>
<summary><strong>🌑 Eclipsed pass (in Earth's shadow)</strong></summary>

```json
{
    "satelliteId": 25544,
    "name": "iss",
    "timestampUtc": "2026-05-22T20:14:55.000Z",
    "latitude": 45.21,
    "longitude": -118.04,
    "altitude": 420.9,
    "velocity": 27590.0,
    "visibility": "eclipsed",
    "footprint": 4536.8,
    "units": "kilometers",
    "scrapedAt": "2026-05-22T20:14:55.220Z"
}
```

</details>

<details>
<summary><strong>📏 Same snapshot in imperial units</strong></summary>

```json
{
    "satelliteId": 25544,
    "name": "iss",
    "timestampUtc": "2026-05-22T18:42:11.000Z",
    "latitude": -12.456,
    "longitude": 78.901,
    "altitude": 261.9,
    "velocity": 17139.0,
    "visibility": "daylight",
    "footprint": 2819.5,
    "units": "miles",
    "scrapedAt": "2026-05-22T18:42:11.123Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🛰️ | **Live precision.** Geodetic latitude, longitude, altitude, and velocity refreshed on every snapshot. |
| 🌐 | **Orbit-path streaming.** Up to 1,000 sequential snapshots in a single run, with a configurable delay. |
| 🌗 | **Visibility flag.** Built-in `daylight` / `eclipsed` indicator for pass-prediction logic. |
| ⚡ | **Fast.** 1 snapshot in under 2 seconds. |
| 📏 | **Unit switch.** Toggle metric and imperial without post-processing. |
| 🔁 | **Always fresh.** Every run re-queries the live feed. |
| 🚫 | **No authentication.** Public data, no login or token required. |

> 📊 Real-time orbital data is the foundation of every ISS visualization, classroom demo, and ham-radio pass alert.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ ISS Live Position Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **Live** | **Per snapshot** | snapshots, delay, units | ⚡ 2 min |
| Local SGP4 propagator from raw TLEs | Free | Live, any sat | Code-driven | Custom | 🐢 Days |
| Commercial space-situational-awareness feeds | $5,000+/year | Many sats | Streaming | Many | ⏳ Weeks |
| Browser-based widgets | Free | Live | Visual only | None | 🕒 Variable |

Pick this Actor when you want clean, structured rows ready for a dashboard or notebook.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the ISS Live Position Scraper page on the Apify Store.
3. 🎯 **Set input.** Leave defaults for one live snapshot, or set `snapshotsPerSatellite` higher for an orbit trail.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **2-4 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎓 Education & EdTech

- Classroom dashboards for STEM lessons
- Live "where is the ISS?" widgets for school portals
- Reproducible labs for orbit-mechanics units
- Museum kiosks and planetarium overlays

</td>
<td width="50%" valign="top">

#### 🛰️ Tracker & Visualizer Apps

- Hourly position pulls for backend caches
- Path overlays on Mapbox, Leaflet, Cesium
- Pass-prediction inputs for ham-radio schedulers
- Notification widgets for sky-watcher apps

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📡 Amateur Radio

- Sked-planning data for ARISS contacts
- Doppler-shift inputs for SDR control software
- Logbook enrichment with position context
- Antenna-rotor automation feeds

</td>
<td width="50%" valign="top">

#### 🎬 Content & Media

- Newsroom space-coverage graphics
- YouTube creator orbit-trail animations
- Live broadcast overlays for launches
- Social media bots that announce flyovers

</td>
</tr>
</table>

***

### 🔌 Automating ISS Live Position Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Minute-by-minute polling keeps a live position cache in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same live snapshots support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Orbital mechanics coursework datasets
- Atmospheric-drag perturbation case studies
- Reproducible position-prediction experiments
- Citizen-science crowd-mapped pass observations

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal sky-watch alert apps
- Generative-art animations driven by orbit data
- Family STEM projects and homeschool labs
- Portfolio data-viz demos for newcomers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Museum and planetarium live displays
- Volunteer ham-radio ARISS school contacts
- Civic STEM-outreach event support
- Open-source contributions to tracker apps

</td>
<td width="50%">

#### 🧪 Experimentation

- Train trajectory-prediction ML toy models
- Validate ground-station antenna-control rigs
- Prototype agent pipelines that react to flyovers
- Test geospatial visualization libraries with live data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20ISS%20Live%20Position%20Scraper%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%20ISS%20Live%20Position%20Scraper%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%20ISS%20Live%20Position%20Scraper%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.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20ISS%20Live%20Position%20Scraper%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?

Set your snapshot count and delay, click Start, and the Actor pulls live position fixes from the where-the-ISS-at live feed. Each snapshot is emitted as one structured row.

#### 📏 How accurate is the position?

Latitude and longitude are propagated from current orbital elements and are accurate to within a few kilometers, which is plenty for visualization and pass prediction. Sub-second-precision use cases should propagate their own state vector from a current TLE.

#### 🔁 How fresh is each snapshot?

Each snapshot reflects the satellite's state at the moment of the request. The source recomputes on demand.

#### 🛰️ Can I track satellites other than the ISS?

The live position feed used here currently exposes only the ISS (NORAD 25544). Any other NORAD ID returns a per-row notice. We will expand coverage as upstream support is added.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor every minute, hour, or day and keep a downstream position cache in sync.

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

Yes. ISS state vectors are propagated from publicly published orbital elements and are free to use for any purpose.

#### 💼 Can I use this data commercially?

Yes. Position data is in the public domain. You remain responsible for downstream regulatory compliance in your own product.

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

No. The free plan is enough for testing and small runs (10 snapshots per run). A paid plan lifts the limit and enables scheduling and higher concurrency.

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

Apify retries transient errors automatically. You can inspect the log in the Runs tab and re-run if needed. Snapshots already captured are preserved.

#### 🌗 What is the visibility flag?

`daylight` means the station is in sunlight (potentially visible from the ground at twilight). `eclipsed` means it is in Earth's shadow.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or the Tally form linked below.

***

### 🔌 Integrate with any app

ISS Live Position Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get flyover alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe position data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh ISS coordinates into your map app, or alert your team in Slack on the next visible pass.

***

### 🔗 Recommended Actors

- [**🛬 OpenSky Flights Scraper**](https://apify.com/parseforge/opensky-flights-scraper) - Real-time aircraft positions worldwide
- [**✈️ OurAirports Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global airport directory
- [**🌦️ NOAA Weather Scraper**](https://apify.com/parseforge/noaa-weather-scraper) - U.S. weather forecasts and observations
- [**🌅 Sunrise & Sunset Times Scraper**](https://apify.com/parseforge/sunrise-sunset-times-scraper) - Solar event times worldwide
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by NASA, Roscosmos, the ISS partner agencies, or any third-party position feed. All trademarks mentioned are the property of their respective owners. Only publicly available open position data is collected.

# Actor input Schema

## `satelliteIds` (type: `array`):

List of NORAD catalog numbers to track. The live position feed currently exposes one satellite: 25544 (International Space Station). Other NORAD IDs will return a per-item error explaining the satellite is not currently tracked. Leave empty to default to the ISS.

## `units` (type: `string`):

Unit system for altitude (km/mi), velocity (km/h, mph), and footprint diameter (km/mi).

## `snapshotsPerSatellite` (type: `integer`):

How many position snapshots to capture for each satellite. 1 = single live reading. Use higher values with delay below to map a flight path.

## `delayBetweenChecksMs` (type: `integer`):

Milliseconds between snapshots. Ignored if snapshotsPerSatellite is 1. Minimum 1000ms to respect the source rate limit.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. Applied across all satellites and snapshots.

## Actor input object example

```json
{
  "satelliteIds": [
    "25544"
  ],
  "units": "kilometers",
  "snapshotsPerSatellite": 1,
  "delayBetweenChecksMs": 5000,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (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 = {
    "satelliteIds": [
        "25544"
    ],
    "units": "kilometers",
    "snapshotsPerSatellite": 1,
    "delayBetweenChecksMs": 5000,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/iss-current-location-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 = {
    "satelliteIds": ["25544"],
    "units": "kilometers",
    "snapshotsPerSatellite": 1,
    "delayBetweenChecksMs": 5000,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/iss-current-location-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 '{
  "satelliteIds": [
    "25544"
  ],
  "units": "kilometers",
  "snapshotsPerSatellite": 1,
  "delayBetweenChecksMs": 5000,
  "maxItems": 10
}' |
apify call parseforge/iss-current-location-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ISS & Satellite Live Position Scraper",
        "description": "Track the International Space Station and any NORAD-cataloged satellite in real time. Pull live latitude, longitude, altitude, velocity, footprint, and visibility. Snapshot once or stream multiple positions over time for path mapping.",
        "version": "1.0",
        "x-build-id": "1dAhxUy0yMRWnPYeR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~iss-current-location-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-iss-current-location-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~iss-current-location-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-iss-current-location-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~iss-current-location-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-iss-current-location-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": {
                    "satelliteIds": {
                        "title": "Satellite NORAD IDs",
                        "type": "array",
                        "description": "List of NORAD catalog numbers to track. The live position feed currently exposes one satellite: 25544 (International Space Station). Other NORAD IDs will return a per-item error explaining the satellite is not currently tracked. Leave empty to default to the ISS.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "units": {
                        "title": "Units",
                        "enum": [
                            "kilometers",
                            "miles"
                        ],
                        "type": "string",
                        "description": "Unit system for altitude (km/mi), velocity (km/h, mph), and footprint diameter (km/mi)."
                    },
                    "snapshotsPerSatellite": {
                        "title": "Snapshots Per Satellite",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many position snapshots to capture for each satellite. 1 = single live reading. Use higher values with delay below to map a flight path."
                    },
                    "delayBetweenChecksMs": {
                        "title": "Delay Between Snapshots (ms)",
                        "minimum": 1000,
                        "maximum": 600000,
                        "type": "integer",
                        "description": "Milliseconds between snapshots. Ignored if snapshotsPerSatellite is 1. Minimum 1000ms to respect the source rate limit."
                    },
                    "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. Applied across all satellites and snapshots."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
