# Launch Library Rocket Launches Scraper (`automation-lab/space-devs-launch-library-upcoming-launches`) Actor

Export upcoming Launch Library rocket missions, launch times, providers, pads and statuses from The Space Devs' official API.

- **URL**: https://apify.com/automation-lab/space-devs-launch-library-upcoming-launches.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** News, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.08 / 1,000 item extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Launch Library Rocket Launches Scraper

Export **launch library rocket launches** from The Space Devs' official public Launch Library 2 API. Get current upcoming missions with stable launch IDs, No Earlier Than (NET) launch times, status, provider, rocket and launch site. Schedule repeat runs to compare snapshots; this Actor does not maintain historical changes or send alerts itself.

### Who is it for?

Aerospace analysts build upcoming launch calendars, newsrooms check current mission times, and data teams export a recurring feed to a spreadsheet or warehouse. A launch time can change between runs: join snapshots on `launchId` and compare `net` and `status`.

### Why use this Actor?

One typed row per launch rather than the API's deeply nested response. It handles pagination, caps results, allows inclusive UTC date bounds and a provider-name filter, and retains canonical source URLs and source-update timestamps. The default dataset works with Apify integrations.

### Getting started

1. Run with `{"maxItems":10}` for the next ten records in the official upcoming endpoint.
2. Optionally set `provider` (for example `SpaceX`) or `startDate` and `endDate` (UTC, `YYYY-MM-DD`).
3. Download the default dataset as JSON, CSV, Excel, or connect a schedule and downstream integration.

### Input parameters

| Parameter | Default | Meaning |
| --- | --- | --- |
| `maxItems` | 50 | Maximum accepted launch rows, 1–500. |
| `provider` | none | Case-insensitive partial launch-service-provider name. |
| `startDate` | none | Inclusive NET UTC day. |
| `endDate` | none | Inclusive NET UTC day. |

The source's `upcoming` route determines which records are available; date filters do not turn this into a historical-launch archive. A provider filter can require multiple pages and is limited by the 100-page safety bound.

### Extracted data

| Field | Meaning |
| --- | --- |
| `launchId` | Stable launch UUID; primary key for snapshot comparisons. |
| `missionId` | Mission identifier when known; not a replacement for launch UUID. |
| `name`, `mission` | Launch and mission names. |
| `net`, `windowStart`, `windowEnd` | Planned launch time and available window, ISO UTC. |
| `status`, `statusId` | Source status at retrieval. |
| `provider`, `rocket`, `pad`, `location` | Provider and launch-site details. |
| `sourceUrl`, `lastUpdated`, `retrievedAt` | Upstream detail link, source update and export snapshot time. |

Nullable detail fields stay null when the source does not supply them.

### Sample output

The following is an abbreviated record from a local September 2026 run; live schedules change:

```json
{
  "launchId": "18441371-8b2e-457c-afb5-1ec1b11ab630",
  "missionId": 6043,
  "name": "Falcon 9 Block 5 | Crew-13",
  "provider": "SpaceX",
  "net": "2026-10-01T15:10:06Z",
  "status": "Go for Launch",
  "sourceUrl": "https://ll.thespacedevs.com/2.3.0/launches/18441371-8b2e-457c-afb5-1ec1b11ab630/"
}
```

### How much does it cost to export upcoming rocket launches?

Pay-per-event billing includes one `start` event per run and one `item` event for every saved launch. At BRONZE the price is $0.00005 per start plus $0.0018 per saved launch. Example estimates: 1 launch costs $0.00185; 10 cost $0.01805; 25 cost $0.04505; 100 cost $0.18005. FREE is $0.00207 per item; SILVER $0.001404; GOLD, PLATINUM and DIAMOND $0.00108 per item. Spend tiers reflect qualifying Apify Store spend, not per-run result volume. No item is charged for filtered-out rows. These are estimates; confirm active pricing in the Pricing tab. Platform usage, adjustments, refunds, fraud, disputes, taxes, corrections and clawbacks can affect final billing and publisher payouts.

### Monitor schedule changes

Schedule a daily run using the same input. Save each run's default dataset to a spreadsheet or warehouse; compare `launchId` plus `net`/`status` between `retrievedAt` snapshots. Absence from an upcoming feed is not proof a mission was cancelled: inspect the canonical detail URL and source status before alerting.

### Integrations

Export the dataset through Apify's Google Sheets integration for an editorial launch calendar, a webhook for downstream ETL, or the dataset API for a daily CSV archive. Each run is an independent snapshot; this Actor does not diff runs or send messages.

### API: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~space-devs-launch-library-upcoming-launches/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"provider":"SpaceX","maxItems":10}'
```

### API: JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/space-devs-launch-library-upcoming-launches').call({ maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API: Python

```python
from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/space-devs-launch-library-upcoming-launches').call(run_input={'maxItems': 10})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP access

In Claude Code, add this Actor to Apify MCP:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/space-devs-launch-library-upcoming-launches'
```

For Claude Desktop, Cursor, or VS Code, configure the HTTP MCP server with `{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/space-devs-launch-library-upcoming-launches"}}}`. Example prompts: "Export the next ten upcoming rocket launches" and "List SpaceX launches with NET and status". This requires an Apify account and applicable MCP authentication.

### Source and reliability

The Actor fetches `ll.thespacedevs.com/2.3.0/launches/upcoming/` directly without a proxy, account, browser, images or video downloads. It uses no AI provider and stores only the run dataset under the user's Apify storage retention settings; no persistent custom cache. The Space Devs is an independent source and does not endorse this Actor. Transient timeouts, HTTP 429 and server errors are retried up to three times with bounded backoff. A malformed response or exhausted retry fails the run rather than returning a misleading empty dataset. A legitimately empty date/provider filter returns zero rows.

### Limits and timestamps

The Launch Library API is maintained by The Space Devs. NET is a planned time, not a guaranteed liftoff. Some rows on the official upcoming endpoint may carry already-successful or outdated NET timestamps; this Actor does not rewrite upstream classifications. A current schedule is not an immutable historical record. API availability, update frequency and rate limits are upstream-controlled. Large or narrow filters can reach the 100-page safety limit and fail explicitly.

### Legality and responsible use

Use public mission information in accordance with The Space Devs' API terms and attribution guidance. Do not present planned launch times as safety-critical operational data. Respect upstream source ownership when redistributing exports; this Actor does not grant rights to linked images or media.

### Troubleshooting and FAQ

**Why did I get no rows?** Check date bounds in UTC and the provider spelling; verify that matching missions are currently present on the official upcoming endpoint.

**Can I retrieve past launches?** No. This product uses the source's upcoming feed; preserve scheduled dataset snapshots for comparisons.

**Does `missionId` uniquely identify a launch?** Use `launchId` (launch UUID) as the row key. `missionId` can be null or shared in source data.

**What happens when the API rate-limits me?** The Actor retries bounded transient failures, then fails visibly. Narrow the date range or reduce request frequency.

### Related Actors

For unrelated source data, browse [automation-lab on Apify](https://apify.com/automation-lab). This Actor is specifically for Launch Library upcoming rocket launch records; it does not aggregate other launch providers.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/space-devs-launch-library-upcoming-launches/changelog.md

# Actor input Schema

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

Maximum matching launch records to save.

## `startDate` (type: `string`):

Optional inclusive NET date, YYYY-MM-DD. Omit for all upcoming launches.

## `endDate` (type: `string`):

Optional inclusive NET date, YYYY-MM-DD.

## `provider` (type: `string`):

Optional case-insensitive partial match of launch service provider name, such as SpaceX.

## Actor input object example

```json
{
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset export.

# 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": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/space-devs-launch-library-upcoming-launches").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": 20 }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/space-devs-launch-library-upcoming-launches").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": 20
}' |
apify call automation-lab/space-devs-launch-library-upcoming-launches --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/space-devs-launch-library-upcoming-launches"
        }
    }
}
```

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/9GcviJj9gMO4VpjcM/builds/PIjgizi2NnfK8UJHJ/openapi.json