# Open Notify ISS Tracker Scraper (`parseforge/opennotify-iss-scraper`) Actor

Collects the current International Space Station position and the list of astronauts in space from the free Open Notify API. Returns each record as a flat row with latitude, longitude, timestamp, astronaut name, and spacecraft.

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

## Pricing

from $4.52 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Open Notify ISS Tracker Scraper

**Track the International Space Station in real time. Get its current latitude, longitude, and timestamp, plus the full list of astronauts in space right now.** Uses the free Open Notify API. No key, no registration. Export to CSV, JSON, Excel, or XML.

The Open Notify API provides live ISS tracking data without authentication, but calling it repeatedly from a script means you handle rate limits, pagination, and data formatting yourself. This Actor polls the API on your schedule, collects the current ISS position and the people in space, and returns every record in one flat, consistent schema. It is the fastest way to pipe real-time space station data into a spreadsheet, dashboard, or database.

| Who uses it | What they scrape Open Notify for |
|---|---|
| STEM educators | Showing students the ISS's real-time location and who is on board during a lesson. |
| Hobbyist developers | Feeding live ISS coordinates into a personal dashboard or map visualization. |
| Data journalists | Capturing astronaut rosters and ISS pass data for a space-themed story. |
| Space enthusiasts | Logging the ISS position over time to analyze its orbital pattern. |

### What it does

This Actor collects the current International Space Station position and the list of astronauts in space from the Open Notify API and returns each record as a flat row.

- 🛰️ **Real-time ISS position:** current latitude, longitude, and a UTC timestamp from the Open Notify server.
- 👨‍🚀 **Astronauts in space:** one row per person, with their name and the spacecraft they are on.
- 🔢 **Configurable record limit:** set a cap from 1 up to 1,000,000 records to control dataset size and cost.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Open Notify data

**🛰️ Build a live ISS tracker dashboard.**

A hobbyist developer runs the Actor every 30 seconds, pipes the latitude and longitude into a mapping library, and displays the station's current position on a personal website.

**👨‍🚀 Monitor crew rotations on the space station.**

A space blogger schedules a daily run that captures the astronaut list, then diffs it against the previous day to detect crew changes and write timely posts.

**📚 Create a classroom STEM activity.**

A teacher runs the Actor at the start of class, exports the CSV, and has students plot the ISS coordinates on a world map while discussing orbital mechanics.

**📈 Log ISS position history for analysis.**

A data enthusiast runs the Actor every minute for a week, accumulates the dataset, and calculates the station's speed and orbital period from the raw coordinates.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | Open Notify is a free, public API with no authentication, and this Actor handles the calls for you. |
| **Flat, predictable schema** | Every run returns the same columns, whether you collect position data, astronaut data, or both. |
| **Runs on autopilot** | Schedule the Actor to poll every few minutes and build a time-series dataset of ISS movements. |

### How it compares

This Actor and the two direct competitors below all pull from the same free Open Notify API. The differences are in which data points each one exposes and how they handle repeated polling.

| Feature | ParseForge | ISS Tracker - Space Station & Astronauts | Iss Tracker Scraper |
|---|---|---|---|
| Current ISS latitude and longitude | Yes | Yes | Yes |
| Current astronauts in space | Yes | Yes | Yes |
| Astronaut spacecraft name | Yes | Not listed | Not listed |
| Configurable record limit for time-series polling | Yes, up to 1,000,000 | Not listed | Not listed |
| Independent toggles for position and astronaut data | Yes | Not listed | Not listed |
| ISS pass predictions for a ground location | Not listed | Not listed | Not listed |

### Configure the run

Toggle the ISS position and astronaut list on or off independently, and set a maximum number of records to collect per run. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Open Notify ISS Tracker Scraper](https://apify.com/parseforge/opennotify-iss-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Open Notify through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/opennotify-iss-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that at least one of 'Include ISS Position' or 'Include Astronauts' is set to true. If both are off, the Actor has nothing to collect. Also verify that your maxItems is set to 1 or higher.

**Why does the Actor return only 10 records when I set a higher limit?**

Free Apify accounts are capped at 10 records per run. Upgrade to a paid plan to collect up to the 1,000,000 record maximum.

**The ISS position seems stale or not updating between runs.**

The API returns a fresh position on each call. If you are scheduling runs, make sure the interval between runs is long enough for the Actor to finish. Check the run logs for any API timeout errors.

**I see duplicate astronaut records in my dataset.**

If you run the Actor multiple times, each run captures the astronaut list as it exists at that moment. Duplicates across runs are expected. Use a deduplication step in your downstream processing if you need a unique list.

**The Actor fails with a timeout error.**

The Open Notify API may occasionally be slow or unavailable. The Actor will retry automatically. If failures persist, wait a few minutes and try again, or check the Open Notify service status.

### FAQ

| Question | Answer |
|---|---|
| Do I need an API key for Open Notify? | No. The Open Notify API is free and public, with no authentication required. This Actor calls it directly on your behalf. |
| How often does the ISS position update? | The Open Notify API returns the station's position at the moment you call it. To track movement over time, schedule the Actor to run at your desired interval, such as every 30 seconds. |
| What does the astronaut list include? | Each astronaut record contains the person's name and the spacecraft they are currently aboard. The list reflects who is in space at the moment the API is called. |
| Can I collect only the ISS position without the astronaut data? | Yes. Set 'Include Astronauts' to false in the input and the Actor will return only the position records. |
| Can I collect only the astronaut list without the position? | Yes. Set 'Include ISS Position' to false and the Actor will return only the astronaut records. |
| What is the maximum number of records I can collect? | Free Apify users are limited to 10 records per run as a preview. Paid users can set the limit up to 1,000,000 records. |
| Why would I collect more than one record if the data is real-time? | The Actor can be scheduled to run repeatedly. Setting a higher record limit allows a single long-running execution to poll the API many times and build a time-series dataset. |
| What format is the timestamp in? | The timestamp is a Unix epoch value in seconds, as returned by the Open Notify API. You can convert it to a human-readable date in your spreadsheet or script. |
| Does this Actor track other satellites? | No. It only queries the Open Notify API, which provides data for the International Space Station. For other satellites, you would need a different data source. |
| Is the ISS position data accurate? | The Open Notify API calculates the position from orbital elements that are updated daily. It is accurate enough for tracking and visualization but is not a real-time navigation-grade source. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Open Notify. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `includeAstronauts` (type: `boolean`):

Include one item per person currently in space (name and spacecraft). Enabled by default.

## `includeIssPosition` (type: `boolean`):

Include one item with the current ISS latitude, longitude and timestamp. Enabled by default.

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

Free users limited to 10 ISS records (preview). Paid users optional, up to 1,000,000.

## Actor input object example

```json
{
  "includeAstronauts": true,
  "includeIssPosition": true,
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/opennotify-iss-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/opennotify-iss-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/opennotify-iss-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/opennotify-iss-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/m9ICCB6ksUuItubUx/builds/TQ4mRJu4pW7fetidL/openapi.json