# Warframe World State API (`automation-lab/warframe-public-game-data-api`) Actor

Fetch normalized Warframe invasions, fissures, sorties, events, alerts, rewards, mission times, source status, and reference items.

- **URL**: https://apify.com/automation-lab/warframe-public-game-data-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 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?

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

## Warframe World State API

Fetch current public Warframe world-state and reference item data as clean, integration-ready dataset records. This **warframe world state api** Actor turns the public `warframestat.us` JSON into consistent records for companion apps, Discord bots, dashboards, spreadsheets, and scheduled community monitoring.

The Actor supports PC, PlayStation, Xbox, and Nintendo Switch world state. It can export invasions, fissures, sortie missions, events, alerts, rewards, mission nodes, activation/expiry timestamps, and source status. A separate item-search mode returns reference identities and selected gameplay metadata.

### What can you fetch?

- Active invasions and competing-faction rewards
- Void fissures with tier, node, enemy, and mission type
- Individual sortie missions with modifiers, nodes, boss, and faction context
- Time-bounded community and recurring events
- Public alerts when the source currently exposes them
- A source-status record with upstream timestamp and build metadata
- Item identities, descriptions, categories, mastery requirements, and selected weapon stats

The default dataset always contains normalized records. Source-specific fields remain available in `details`, so downstream users get stable common columns without losing useful entity metadata.

### Who is this Actor for?

**Companion app developers** can refresh time-sensitive activities without maintaining their own upstream adapter.

**Community bot operators** can schedule runs and notify members when fissures, sorties, invasions, or rewards change.

**Data analysts** can export current snapshots to JSON, CSV, Excel, or a warehouse for comparisons.

**Wiki and tool maintainers** can search item identities and reconcile canonical `uniqueName` values.

### Why use this Actor?

- No Warframe login or API key is required.
- One bounded public JSON request powers each run.
- Common identity, timing, platform, status, and reward fields are normalized.
- Expired/completed rows can be filtered before they reach your dataset.
- Retries are limited to transient network, 429, and server failures.
- Apify scheduling, webhooks, datasets, API clients, and MCP work immediately.

This Actor does not scrape player accounts, inventories, trades, market prices, historical snapshots, or private game data.

### Input parameters

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `mode` | string | `worldState` | Choose `worldState` or `items`. |
| `platform` | string | `pc` | Choose `pc`, `ps4`, `xb1`, or `swi`. |
| `recordTypes` | string\[] | all supported types | Select invasions, fissures, sorties, events, alerts, and/or status. |
| `itemQuery` | string | `Rubico` prefill | Item name fragment required in `items` mode. |
| `activeOnly` | boolean | `true` | Exclude records explicitly expired or completed. |
| `maxItems` | integer | `100` | Save at most 1–1000 normalized records. |

`recordTypes` applies only to world-state mode. `itemQuery` applies only to item mode. Item reference data is shared even though every output retains the selected platform for run context.

### Getting started

1. Open the Actor in Apify Console.
2. Keep `worldState` mode for a current activity snapshot.
3. Select the game platform.
4. Choose the entity groups your integration needs.
5. Set `maxItems` high enough for the selected groups.
6. Click **Start**.
7. Open the default dataset and choose JSON, CSV, XML, RSS, or Excel export.
8. Add a schedule or webhook when you need recurring monitoring.

A useful first run is:

```json
{
  "mode": "worldState",
  "platform": "pc",
  "recordTypes": ["fissures", "sorties", "status"],
  "activeOnly": true,
  "maxItems": 100
}
```

### Output fields

| Field | Meaning |
| --- | --- |
| `recordType` | `invasion`, `fissure`, `sortieMission`, `event`, `alert`, `sourceStatus`, or `item`. |
| `entityId` | Stable upstream ID or item unique name. |
| `name` | Human-readable name, description, or boss when available. |
| `node` | Warframe mission node. |
| `missionType` | Mission type when exposed. |
| `activation` | Upstream ISO activation timestamp. |
| `expiry` | Upstream ISO expiry timestamp. |
| `active` | Derived active state, or `null` where expiry is not applicable. |
| `rewards` | Flattened reward/item names found on the entity. |
| `platform` | Requested platform code. |
| `sourceStatus` | `ok` for successfully normalized public source data. |
| `sourceTimestamp` | Timestamp reported by the world-state source. |
| `sourceUrl` | Exact public endpoint used by the run. |
| `fetchedAt` | ISO timestamp when the Actor normalized the record. |
| `details` | Entity-specific structured fields from the source or selected item metadata. |

### Example output

```json
{
  "recordType": "fissure",
  "entityId": "6aa0dba2115710aa2ef54f48",
  "name": null,
  "node": "Tiwaz (Void)",
  "missionType": "Mobile Defense",
  "activation": "2026-09-09T04:08:02.697Z",
  "expiry": "2026-09-09T06:03:18.455Z",
  "active": true,
  "rewards": [],
  "platform": "pc",
  "sourceStatus": "ok",
  "sourceTimestamp": "2026-09-09T05:59:08.000Z",
  "sourceUrl": "https://api.warframestat.us/pc",
  "fetchedAt": "2026-09-09T06:00:00.000Z",
  "details": {
    "tier": "Axi",
    "enemy": "Orokin",
    "isStorm": false,
    "isHard": false
  }
}
```

Values change with the live game state. Treat this as a field-shape example, not a promise that the shown mission remains active.

### How much does it cost to fetch Warframe world state records?

The Actor uses pay per event: one small start event plus one `item` event for each normalized record saved. The active tier price is shown in Apify Console before your run.

At the BRONZE price of **$0.001592 per record** plus a **$0.005 run start**, approximate examples are:

- 10 records: approximately 2.092 cents
- 50 records: approximately 8.460 cents
- 100 records: approximately 16.420 cents

Higher account tiers receive the tier price shown by Apify. Empty or rejected records are not charged as items. Actual totals depend on the number of currently available records and the selected `maxItems` limit.

### Scheduled monitoring workflow

1. Select only the changing entity groups your bot or dashboard needs.
2. Include `status` to retain the source refresh timestamp.
3. Create an Apify schedule at a sensible interval.
4. Send the dataset to a webhook, Make, Zapier, Google Sheets, or your own endpoint.
5. Deduplicate or compare by `recordType` plus `entityId`.
6. Use `activation`, `expiry`, and `active` to drive notifications.

The Actor produces snapshots. It does not persist a historical timeline or label rows as newly changed. Store previous datasets in your own workflow when change detection is required.

### Item reference search

Use item mode for a real name fragment:

```json
{
  "mode": "items",
  "itemQuery": "Rubico",
  "platform": "pc",
  "maxItems": 20
}
```

Each result exposes the canonical identity in `entityId`, a human-readable `name`, and selected fields such as description, category, mastery requirement, tradability, damage, critical chance, and status chance inside `details` when available.

Search is source-defined substring matching. Broad fragments may return several variants. Use an exact `name` comparison downstream when you need one specific item.

### Use the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~warframe-public-game-data-api/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"worldState","platform":"pc","recordTypes":["fissures","sorties","status"],"maxItems":100}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/warframe-public-game-data-api').call({
  mode: 'items',
  itemQuery: 'Rubico',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("automation-lab/warframe-public-game-data-api").call(run_input={
    "mode": "worldState",
    "platform": "pc",
    "recordTypes": ["invasions", "events", "status"],
    "activeOnly": True,
    "maxItems": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/warframe-public-game-data-api"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this equivalent desktop/editor configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/warframe-public-game-data-api"
    }
  }
}
```

Example prompts:

- “Fetch current PC fissures and summarize each mission node, tier, and expiry.”
- “Search Warframe reference items for Rubico and compare critical statistics.”
- “Get current invasions and format their competing rewards for a Discord post.”

### Integrations

- **Discord or Slack:** trigger messages from scheduled dataset webhooks.
- **Google Sheets:** maintain a current activities table for a community.
- **Make or Zapier:** route selected reward or mission records into notifications.
- **BigQuery or a warehouse:** retain snapshots for your own historical analysis.
- **Custom apps:** consume the dataset through REST, JavaScript, or Python clients.

Use `entityId` as the natural identity and retain `platform` in multi-platform workflows.

### Related Actors

Explore other public-data and developer-tool Actors from [automation-lab](https://apify.com/automation-lab). Choose related products only when they fit your workflow; this Actor remains focused on current Warframe world state and reference items.

### Limits and reliability

The Actor depends on the public `warframestat.us` community API and Digital Extremes game-state availability. Upstream fields, translations, schedules, and refresh timing can change.

Transient 429 and server/network failures are retried up to three attempts. Deterministic client errors and malformed responses fail the run instead of returning misleading output. There is no hidden proxy or browser fallback.

`activeOnly` excludes records known to be expired or completed. Entities without a meaningful expiry remain included. A selected group may naturally be empty—for example, there may be no alerts at the time of a run.

`maxItems` applies after normalization. Sorties are emitted as individual mission rows, so one current sortie normally creates multiple useful records.

### Legality and responsible use

This Actor accesses public community API data without logging into Warframe. Follow Apify’s terms, the upstream service’s policies, and applicable law. Use sensible schedules, avoid unnecessary high-frequency polling, and cache results in applications with many users.

Warframe and related names are trademarks of their respective owners. This independent Actor is not affiliated with or endorsed by Digital Extremes or the upstream API maintainers.

Do not present community data as an official uptime guarantee, financial record, or authoritative account status.

### Troubleshooting

#### Why did I get fewer records than `maxItems`?

`maxItems` is a ceiling, not a target. Current activity groups have naturally variable sizes, and `activeOnly` removes expired/completed rows.

#### Why are there no alerts?

The public source can legitimately report an empty alerts array. Include fissures, invasions, sorties, events, or `status` when your workflow needs a useful snapshot even during alert-free periods.

#### Why did item mode fail?

Provide an `itemQuery` between 2 and 100 characters and keep `mode` set to `items`. Very broad or unknown text can return zero matches.

#### What does `sourceStatus: ok` mean?

It means the HTTP request and normalization succeeded. It is not an official game-server health verdict.

### FAQ

#### Does the Actor return historical data?

No. It returns the current source snapshot. Schedule runs and retain their datasets if your application needs history.

#### Does it return Warframe Market prices?

No. Item mode serves reference identities and selected metadata, not player orders or trading prices.

#### Does it require a Warframe account?

No. The supported source is public and requires no login.

#### Can I fetch several platforms in one run?

One run targets one platform. Create separate Tasks or runs for platform-specific snapshots.

#### Are rewards normalized?

Common reward names are flattened into `rewards`, while complete source context remains in `details`.

#### Can I use the Actor in a commercial companion app?

Technically yes, through Apify’s APIs and integrations. You remain responsible for upstream terms, trademarks, attribution, caching, and your application’s legal requirements.

# Actor input Schema

## `mode` (type: `string`):

Fetch current world state or search reference items.

## `platform` (type: `string`):

Warframe platform for world-state data. Item reference data is shared.

## `recordTypes` (type: `array`):

Entity groups to export in worldState mode.

## `itemQuery` (type: `string`):

Item name fragment, such as Rubico or Prime. Required only in items mode.

## `activeOnly` (type: `boolean`):

Exclude records explicitly completed or expired. Records without expiry remain included.

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

Maximum normalized dataset records to save (1–1000).

## Actor input object example

```json
{
  "mode": "worldState",
  "platform": "pc",
  "recordTypes": [
    "invasions",
    "fissures",
    "sorties",
    "events",
    "alerts",
    "status"
  ],
  "itemQuery": "Rubico",
  "activeOnly": true,
  "maxItems": 20
}
```

# Actor output Schema

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

Open normalized records in the overview table view.

# 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 = {
    "mode": "worldState",
    "platform": "pc",
    "recordTypes": [
        "invasions",
        "fissures",
        "sorties",
        "events",
        "alerts",
        "status"
    ],
    "itemQuery": "Rubico",
    "activeOnly": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/warframe-public-game-data-api").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 = {
    "mode": "worldState",
    "platform": "pc",
    "recordTypes": [
        "invasions",
        "fissures",
        "sorties",
        "events",
        "alerts",
        "status",
    ],
    "itemQuery": "Rubico",
    "activeOnly": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/warframe-public-game-data-api").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 '{
  "mode": "worldState",
  "platform": "pc",
  "recordTypes": [
    "invasions",
    "fissures",
    "sorties",
    "events",
    "alerts",
    "status"
  ],
  "itemQuery": "Rubico",
  "activeOnly": true,
  "maxItems": 20
}' |
apify call automation-lab/warframe-public-game-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/warframe-public-game-data-api"
        }
    }
}
```

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/TR1djYHW3asn7o2IQ/builds/gqEdNmGRawlCsiIk5/openapi.json