# NOAA SWPC Space Weather Scraper (`parseforge/noaa-swpc-space-weather-scraper`) Actor

Track space weather from NOAA SWPC across five products. Pull the planetary Kp index, solar wind speed, density, Bt and Bz, GOES solar flare flux, live alerts, and sunspot numbers, each stamped in UTC. Great for aurora forecasting, radio blackout watching, and solar cycle research.

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

## Pricing

from $6.00 / 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 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)

## 🛰️ NOAA SWPC Space Weather Scraper

> 🚀 **Export live space weather data in seconds.** Pull the planetary Kp index, solar wind, GOES X-ray flux, official alerts, and sunspot numbers straight from NOAA's Space Weather Prediction Center.

> 🕒 **Last updated:** 2026-06-04 · **📊 Up to 8 fields** per record · **5 products** · global geomagnetic and solar coverage

Track geomagnetic storms, solar flares, and solar wind conditions using the same public feeds NOAA publishes for forecasters. This Actor reads the keyless SWPC product endpoints and returns clean, per product records with the newest readings first.

Coverage spans five distinct products. Geomagnetic activity through the planetary Kp index, real time solar wind plasma and magnetic field from the DSCOVR and ACE missions, GOES X-ray flux for flare detection, the full live feed of space weather warnings and alerts, and monthly sunspot numbers going back to 1749.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Aurora chasers and photographers | Forecast aurora visibility from Kp and Bz |
| HF radio and satellite operators | Watch X-ray flux and geomagnetic storms |
| Researchers and data scientists | Build space weather time series and models |
| Power grid and aviation analysts | Monitor alerts that affect infrastructure |

### 📋 What the NOAA SWPC Space Weather Scraper does

This Actor connects to the NOAA Space Weather Prediction Center public product feeds and returns structured records for the product you choose. Each product has its own clean record shape, so you never get columns full of values that belong to a different product.

- **Planetary Kp Index** geomagnetic activity index with running a index and station count.
- **Solar Wind** speed, density, temperature, total field Bt, and the southward Bz component.
- **GOES X-ray Flux** short and long wavelength flux used to classify solar flares.
- **Space Weather Alerts** the live feed of NOAA warnings, watches, and summaries with parsed codes.
- **Sunspot Numbers** monthly observed and smoothed sunspot numbers plus the F10.7 radio flux.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

Choose a product, then optionally cap how many records you want. The newest readings are returned first.

| Field | Type | Description |
|---|---|---|
| `product` | select | Which SWPC product to collect. One of `kp-index`, `solar-wind`, `xray-flux`, `alerts`, `sunspots`. |
| `maxItems` | integer | Maximum number of records to return. Free plan is limited to 10. |

Example, the latest planetary Kp index readings:

```json
{
  "product": "kp-index",
  "maxItems": 10
}
````

Example, the most recent solar wind conditions:

```json
{
  "product": "solar-wind",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Solar wind Bt and Bz come from the magnetometer feed and are matched to plasma readings by timestamp. At the very newest minute the magnetometer point can lag the plasma point, so a couple of leading rows may carry a null Bt or Bz until the next reading lands. Sunspot rows older than the modern record use a NOAA no data marker that this Actor normalizes to null.

### 📊 Output

Each record below is from a real run of this Actor.

**Planetary Kp Index** record shape:

| Field | Description |
|---|---|
| 🛰 `product` | Product identifier, here `kp-index` |
| 🕒 `time` | UTC timestamp of the reading |
| 🧲 `kp` | Planetary Kp index value |
| 📈 `aRunning` | Running a index |
| 📡 `stationCount` | Number of contributing magnetometer stations |
| 🕒 `scrapedAt` | When this record was collected |
| ❌ `error` | Error message, null on success |

Real sample records:

```json
{
  "product": "kp-index",
  "time": "2026-06-04T15:00:00",
  "kp": 1,
  "aRunning": 4,
  "stationCount": 8,
  "scrapedAt": "2026-06-04T19:38:42.821Z",
  "error": null
}
```

```json
{
  "product": "kp-index",
  "time": "2026-06-04T12:00:00",
  "kp": 1.67,
  "aRunning": 6,
  "stationCount": 8,
  "scrapedAt": "2026-06-04T19:38:42.821Z",
  "error": null
}
```

```json
{
  "product": "solar-wind",
  "time": "2026-06-04 19:35:00.000",
  "speed": 433.1,
  "density": 1.46,
  "temperature": 57415,
  "bt": 3.61,
  "bz": 1.86,
  "scrapedAt": "2026-06-04T19:38:56.616Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Per product clean records.** Every product returns only the fields that belong to it, so there are no permanently empty columns.
- **Newest first.** Records arrive sorted from most recent to oldest, ready for dashboards and alerting.
- **No keys, no setup.** The SWPC feeds are public, so there is nothing to register or configure.
- **Parsed alerts.** Raw alert text is parsed into a message code, serial number, and a one line summary.
- **Faithful to the source.** Values are passed through as NOAA publishes them, with only no data markers normalized to null.

### 📈 How it compares to alternatives

| Capability | This Actor | Manual feed reading | Generic API client |
|---|---|---|---|
| Five SWPC products in one place | Yes | Partial | No |
| Clean per product record shapes | Yes | No | No |
| Parsed alert codes and summaries | Yes | No | No |
| Newest first ordering | Yes | No | No |
| No API key required | Yes | Yes | Varies |

### 🚀 How to use

1. Create a free Apify account using [this sign up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the NOAA SWPC Space Weather Scraper in the Apify Console.
3. Pick a `product`, for example `kp-index` for geomagnetic activity or `xray-flux` for flares.
4. Set `maxItems` if you want to cap how many records come back.
5. Click Start, then view or connect the results to your tools.

### 💼 Business use cases

#### Aurora and tourism

| Need | How this helps |
|---|---|
| Predict aurora visibility | Combine Kp index with solar wind Bz |
| Time customer notifications | Watch alerts for geomagnetic storm watches |

#### Communications and navigation

| Need | How this helps |
|---|---|
| Anticipate HF radio blackouts | Track GOES X-ray flux for flare onset |
| Manage GNSS accuracy risk | Monitor storm alerts and Kp spikes |

#### Power and infrastructure

| Need | How this helps |
|---|---|
| Flag induced current risk | Read geomagnetic warnings as they post |
| Plan maintenance windows | Use Kp trends to pick quiet periods |

#### Research and education

| Need | How this helps |
|---|---|
| Build space weather datasets | Pull long sunspot and solar cycle history |
| Teach solar physics | Show live flux and sunspot relationships |

### 🔌 Automating NOAA SWPC Space Weather Scraper

Connect the output to the tools your team already uses.

- **Make** trigger a scenario when a new geomagnetic alert appears.
- **Zapier** push fresh Kp readings into a spreadsheet on a schedule.
- **Slack** post a message when X-ray flux crosses a flare threshold.
- **Airbyte** sync space weather records into a warehouse.
- **GitHub** store snapshots in a repository for versioned history.
- **Google Drive** archive periodic pulls for later analysis.

### 🌟 Beyond business use cases

- **Research** assemble decades of sunspot and F10.7 data for solar cycle studies.
- **Personal** get a heads up when aurora conditions look promising at your latitude.
- **Non-profit** support amateur radio and citizen science communities with shared feeds.
- **Experimentation** prototype a space weather model on real Kp and solar wind series.

### 🤖 Ask an AI assistant

Paste your collected records into an assistant and ask it to summarize conditions.

- [ChatGPT](https://chat.openai.com/)
- [Claude](https://claude.ai/)
- [Perplexity](https://www.perplexity.ai/)
- [Microsoft Copilot](https://copilot.microsoft.com/)

### ❓ Frequently Asked Questions

**Where does the data come from?**
From the NOAA Space Weather Prediction Center public product feeds at services.swpc.noaa.gov.

**Do I need an API key?**
No. The SWPC feeds are public and keyless, so there is nothing to register.

**Which products are available?**
Planetary Kp index, solar wind, GOES X-ray flux, space weather alerts, and sunspot numbers.

**Why do some solar wind rows have a null Bt or Bz?**
Bt and Bz come from the magnetometer feed and are matched to plasma readings by timestamp. The newest minute can lag, so a leading row or two may be null until the next reading lands.

**Why are some older sunspot fields null?**
Historical rows use a NOAA no data marker for fields that were not measured. This Actor normalizes that marker to null.

**How fresh is the data?**
As fresh as NOAA publishes. Kp updates roughly every three hours, solar wind and X-ray flux update on the order of minutes.

**In what order are records returned?**
Newest first, from the most recent reading back through the available history.

**How many records can I get?**
Free plans return up to 10 records. Paid plans can return far more, up to the product history available.

**Can I scrape alerts only?**
Yes. Set `product` to `alerts` to get the live warning and watch feed with parsed codes.

**Is the alert text included?**
Yes. Each alert record includes the full message text plus a parsed code, serial number, and summary line.

**Is this affiliated with NOAA?**
No. This is an independent tool that reads publicly available NOAA data.

**What time zone are timestamps in?**
NOAA publishes these feeds in UTC, and timestamps are passed through unchanged.

### 🔌 Integrate with any app

Send your records to spreadsheets, databases, dashboards, or messaging tools through Apify integrations, webhooks, or the API.

### 🔗 Recommended Actors

- [APOD NASA Images Scraper](https://apify.com/parseforge/apod-nasa-images-scraper)
- [NASA NEOWS Asteroids Scraper](https://apify.com/parseforge/nasa-neows-asteroids-scraper)
- [Launch Library SpaceDevs Launch Scraper](https://apify.com/parseforge/ll-spacedevs-launch-scraper)
- [USGS Earthquake Scraper](https://apify.com/parseforge/usgs-earthquake-scraper)
- [NOAA Weather Scraper](https://apify.com/parseforge/noaa-weather-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with NOAA or its Space Weather Prediction Center. Only publicly available data is collected.

# Actor input Schema

## `product` (type: `string`):

Which NOAA SWPC product to collect. Each product returns its own clean set of fields.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "product": "kp-index",
  "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/noaa-swpc-space-weather-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/noaa-swpc-space-weather-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 '{
  "maxItems": 10
}' |
apify call parseforge/noaa-swpc-space-weather-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA SWPC Space Weather Scraper",
        "description": "Track space weather from NOAA SWPC across five products. Pull the planetary Kp index, solar wind speed, density, Bt and Bz, GOES solar flare flux, live alerts, and sunspot numbers, each stamped in UTC. Great for aurora forecasting, radio blackout watching, and solar cycle research.",
        "version": "0.1",
        "x-build-id": "6rHHhmuqpQDzf0bk6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~noaa-swpc-space-weather-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-noaa-swpc-space-weather-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~noaa-swpc-space-weather-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-noaa-swpc-space-weather-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~noaa-swpc-space-weather-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-noaa-swpc-space-weather-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",
                "required": [
                    "product"
                ],
                "properties": {
                    "product": {
                        "title": "Space Weather Product",
                        "enum": [
                            "kp-index",
                            "solar-wind",
                            "xray-flux",
                            "alerts",
                            "sunspots"
                        ],
                        "type": "string",
                        "description": "Which NOAA SWPC product to collect. Each product returns its own clean set of fields.",
                        "default": "kp-index"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```