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:

{
  "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

{
  "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:

{
  "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

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

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

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:

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:

{
  "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. 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.