# Warframe Market Scraper (`automation-lab/warframe-market-mod-prices`) Actor

Export current Warframe Market mod buy and sell orders with rank, platinum price, trader activity, reputation, timestamps, and price summaries.

- **URL**: https://apify.com/automation-lab/warframe-market-mod-prices.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Games
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.30 / 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 Market Scraper

Export current public **Warframe Market** mod buy and sell orders as structured data.
Select mods by name, catalog search, and source tags, then receive rank-aware platinum prices,
quantities, trader activity, reputation, timestamps, and normalized price summaries.

The Actor is designed for repeatable Warframe mod valuation rather than manual page checking.
Each dataset row is one visible marketplace order, ready for JSON, CSV, Excel, APIs, schedules,
and downstream analytics.

### What does Warframe Market Scraper do?

The Actor:

- resolves exact mod names such as `Serration` and `Primed Continuity`;
- searches the current marketplace catalog by text;
- requires source-native tags such as `mod`, `legendary`, `rare`, or `rifle`;
- fetches current public buy and sell orders;
- filters orders by rank and trader activity status;
- exports platinum price, quantity, order side, and source timestamps;
- includes public trader reputation, platform, cross-play, and activity fields when exposed;
- calculates rank-specific lowest and median sell prices;
- calculates rank-specific highest and median buy prices;
- records an `observedAt` timestamp for recurring snapshots.

It uses Warframe Market's public structured data surface. No game account, marketplace login,
or browser automation is required.

### Who is this Actor for?

**Warframe traders** can compare active listings before buying or selling a ranked mod.

**Game-economy analysts** can schedule comparable snapshots and study platinum-price spreads.

**Community tool builders** can feed current order rows into dashboards, Discord bots, or sheets.

**Data teams** can export clean marketplace records without maintaining catalog resolution,
retry handling, rank grouping, or API normalization.

Choose [Warframe World State API](https://apify.com/automation-lab/warframe-public-game-data-api)
for invasions, fissures, sorties, alerts, and reference items instead of player-market orders.

### Why use it instead of checking listings manually?

A marketplace page is useful for one decision. Structured runs are useful for repeated decisions.
The Actor creates a stable row shape across multiple mods and makes every observation traceable.

Important differences include:

1. exact and catalog-based mod selection in one input;
2. the same rank, order-side, and activity filters across every selected mod;
3. both raw order facts and a comparable rank-level summary;
4. hard caps for predictable scheduled runs;
5. bounded retries for temporary rate limits and upstream server errors;
6. no automatic residential proxy or browser fallback.

### What Warframe mod price data is extracted?

| Field | Meaning |
| --- | --- |
| `itemId`, `itemName`, `itemSlug` | Stable marketplace identity and English name |
| `itemUrl`, `itemTags`, `itemMaxRank` | Public page, catalog labels, and maximum rank |
| `orderId`, `orderType` | Stable listing ID and `buy` or `sell` side |
| `platinum`, `quantity`, `rank` | Listed platinum, offered quantity, and mod rank |
| `subtype`, `visible` | Source subtype and visibility state |
| `sellerName`, `sellerReputation` | Public trader name and marketplace reputation |
| `sellerStatus`, `sellerLastSeen` | Public activity status and last-seen timestamp |
| `sellerPlatform`, `sellerCrossplay` | Account platform and cross-play indicator |
| `sellerActivityType`, `sellerActivityDetails` | Extra public activity fields when exposed |
| `orderCreatedAt`, `orderUpdatedAt` | Source order timestamps |
| `priceSummary` | Rank-specific counts and lowest/highest/median prices |
| `sourceUrl`, `observedAt` | API provenance and run observation time |

All source-dependent fields may be absent or null in future upstream responses.
The complete machine-readable contract is attached to the default dataset.

### How to run the Warframe Market mod price scraper

1. Open the Actor in Apify Console.
2. Enter one or more exact **Mod names**, or set a **Catalog search**.
3. Keep the default `mod` tag unless you intentionally want another catalog class.
4. Choose buy orders, sell orders, or both.
5. Select trader activity statuses and optional ranks.
6. Set mod, per-mod order, and total record caps.
7. Click **Start**.
8. Open the Dataset tab and export JSON, CSV, Excel, XML, or RSS.

A safe first run is:

```json
{
  "itemNames": ["Serration"],
  "orderTypes": ["sell", "buy"],
  "userStatuses": ["ingame", "online"],
  "maxMods": 1,
  "maxOrdersPerMod": 20,
  "maxItems": 20
}
```

### Input parameters

#### `itemNames`

An array of exact Warframe Market mod names or slugs. Matching is case-insensitive and treats
underscores like spaces. Up to 50 names are accepted. If supplied, each output mod must match one
of these names.

#### `searchQuery`

Optional text contained in a mod name or slug. Use at least two characters. `primed` discovers
mods whose current catalog names include that term.

#### `tags`

Every selected catalog item must contain every supplied source-native tag. The default is
`["mod"]`, which prevents non-mod marketplace items from entering results. Useful combinations
include `mod + legendary`, `mod + rare`, and `mod + rifle`.

#### `orderTypes`

Choose `sell`, `buy`, or both. The default includes both sides.

#### `userStatuses`

Choose `ingame`, `online`, and/or `offline`. The default includes active in-game and online users.
Set an empty list to retain all statuses, including offline orders.

#### `ranks`

Optional integer ranks from 0 to 20. An empty list includes every listed rank.

#### Result limits

- `maxMods` limits selected catalog mods from 1 to 50.
- `maxOrdersPerMod` limits exported matching orders for each mod from 1 to 1,000.
- `maxItems` limits the entire default dataset from 1 to 5,000 rows.

The first reached limit wins. Summary counts and prices are calculated before the per-mod output
cap, after order-side, activity, rank, and visibility filters.

### Example output

A current row has this shape; the trader name below is anonymized:

```json
{
  "recordType": "order",
  "itemId": "54a74454e779892d5e515596",
  "itemName": "Serration",
  "itemSlug": "serration",
  "itemUrl": "https://warframe.market/items/serration",
  "itemTags": ["mod", "uncommon", "rifle", "primary"],
  "itemMaxRank": 10,
  "orderId": "6a70b87c90780835bc384d68",
  "orderType": "sell",
  "platinum": 2,
  "quantity": 1,
  "rank": 0,
  "subtype": "regular",
  "visible": true,
  "sellerName": "SampleTrader",
  "sellerReputation": 8,
  "sellerStatus": "ingame",
  "sellerPlatform": "pc",
  "sellerCrossplay": true,
  "sellerLastSeen": "2025-01-15T12:00:00Z",
  "sellerActivityType": "UNKNOWN",
  "sellerActivityDetails": "unknown",
  "orderCreatedAt": "2025-01-10T08:30:00Z",
  "orderUpdatedAt": "2025-01-14T18:20:00Z",
  "priceSummary": {
    "rank": 0,
    "sellOrderCount": 6,
    "lowestSellPrice": 2,
    "medianSellPrice": 3.5,
    "buyOrderCount": 2,
    "highestBuyPrice": 1,
    "medianBuyPrice": 1
  },
  "sourceUrl": "https://api.warframe.market/v2/orders/item/serration",
  "observedAt": "2025-01-15T12:05:00.000Z"
}
```

Prices are marketplace listings, not guaranteed completed-sale values.

### Understanding normalized price summaries

`priceSummary` is grouped by mod and exact rank after your filters are applied.
For sell orders, lower prices generally represent cheaper visible supply.
For buy orders, higher prices generally represent stronger visible demand.

The summary includes:

- matching sell and buy order counts;
- lowest sell and highest buy platinum prices;
- median sell and buy prices;
- the rank shared by those orders.

The same summary is repeated on each matching row so flat CSV and spreadsheet exports remain
self-contained. A missing side is represented by a zero count and null price fields.

### How much does it cost to export Warframe Market mod orders?

Pricing uses pay per event: one small start event plus one `item` event for each order written to
the default dataset. The exact current rates appear in Apify Console before you start a run.

At the current provisional BRONZE rate of $0.005 per run plus $0.017164 per order:

- 10 orders cost about **$0.17664**;
- 50 orders cost about **$0.86320**;
- 100 orders cost about **$1.72140**.

Apify plan tiers can use different per-order rates. Limits make the maximum number of charged rows
explicit. Failed, rejected, duplicate, or filtered-out source orders are not saved as results and
do not receive an item event.

### Recurring valuation workflows

For a comparable price watchlist:

1. use the same `itemNames`, ranks, statuses, and order sides every run;
2. keep limits high enough that truncation does not distort comparison;
3. schedule the Actor hourly, daily, or weekly in Apify;
4. retain `observedAt`, `orderUpdatedAt`, and `orderId` downstream;
5. compare rank-specific lowest sell, highest buy, and median values;
6. alert only after applying your own spread or volume threshold.

Apify integrations can send completed datasets to Google Sheets, webhooks, Make, Zapier, Slack,
or a custom HTTP service.

### Export to spreadsheets and data pipelines

From the Dataset tab, download CSV or Excel for manual analysis. For automation, consume the
default dataset API and key records by `orderId`. `observedAt` identifies the snapshot while
`orderUpdatedAt` indicates when the marketplace says a listing changed.

For historical analysis, store each run separately or append rows to your own warehouse.
The Actor reports current observations; it does not maintain a hidden cross-run price-history
store and does not claim that visible listings became completed trades.

### Use the Actor through the Apify API

Replace `APIFY_TOKEN` with your token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~warframe-market-mod-prices/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"itemNames":["Serration"],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/warframe-market-mod-prices').call({
  itemNames: ['Primed Continuity', 'Blind Rage'],
  ranks: [10],
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("automation-lab/warframe-market-mod-prices").call(run_input={
    "searchQuery": "primed",
    "tags": ["mod", "legendary"],
    "orderTypes": ["sell"],
    "maxItems": 30,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/warframe-market-mod-prices"
```

#### Claude Desktop setup

Add this server to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/warframe-market-mod-prices"
    }
  }
}
```

#### Cursor setup

In Cursor, open **Settings → Tools & MCP → Add custom MCP** and use the same server URL:
`https://mcp.apify.com?tools=automation-lab/warframe-market-mod-prices`.

#### VS Code setup

In VS Code with MCP support, add an HTTP MCP server named `apify` with that Actor-specific URL
to your workspace or user MCP configuration.

Example prompts:

- “Export active Serration buy and sell orders and compare rank 0 and rank 10 prices.”
- “Find three legendary mods containing Primed and return the cheapest online sell orders.”
- “Run my max-rank Primed Continuity and Blind Rage watchlist and save the dataset.”

### Reliability, limits, and failure behavior

The Actor makes one catalog request plus one order request for each selected mod.
Temporary HTTP 429 and server errors receive at most three bounded attempts with backoff.
Network timeouts are retried within the same bound. Stable 4xx responses, malformed JSON,
and changed response shapes fail the run instead of returning a misleading empty success.

The Actor intentionally has no proxy or browser fallback. This keeps runtime cost predictable
while the public v2 structured source works directly. Source maintenance, rate limits, catalog
changes, and marketplace outages can still affect availability.

A valid selector with no matching catalog mods returns an empty dataset and a warning.
Some requested exact names matching no current tradable mod are also reported in logs.

### Tips for useful results

- Keep the default `mod` tag unless broad marketplace data is intentional.
- Use exact names for stable scheduled watchlists.
- Use search plus tags for discovery workflows.
- Include offline users only when historical listing depth matters more than contactability.
- Compare prices only within the same rank.
- Use `maxOrdersPerMod` high enough to avoid clipping distributions.
- Check the dataset count and Actor logs when a query naturally has no active listings.
- Treat public user activity as transient marketplace metadata, not proof of availability.

### Responsible use and legality

This Actor reads public marketplace catalog and order data. Use it in accordance with Warframe
Market terms, Apify policies, and applicable laws. Do not use public trader fields for harassment,
spam, profiling unrelated to trading, or attempts to identify private individuals.

Minimize retained personal data, set appropriate retention periods, and secure exported datasets.
The Actor is not affiliated with Digital Extremes or Warframe Market. Warframe names and related
marks belong to their respective owners.

### Related Automation Lab Actors

- [Warframe World State API](https://apify.com/automation-lab/warframe-public-game-data-api) — invasions, fissures, sorties, events, alerts, source status, and public reference items.

Related Actors solve different jobs. This Actor is specifically for player-market mod listings
and platinum valuation.

### Troubleshooting

#### Why did my run return no records?

Confirm that exact names are current tradable mod names, retain the `mod` tag, and loosen rank or
activity filters. A mod can have no online or in-game listings at a particular rank.

#### Why is a requested mod missing?

Exact `itemNames` do not perform fuzzy spelling correction. Copy the current marketplace name or
use `searchQuery` to discover the canonical spelling.

#### Why are summary counts larger than exported rows?

Summaries use all matching visible orders before `maxOrdersPerMod` truncates output. This preserves
market depth context even when you request only the most actionable rows.

#### Why did the run fail with an upstream HTTP error?

Inspect logs for the status and endpoint. Temporary 429 and 5xx responses are already retried.
A persistent failure can indicate an upstream outage or incompatible public API change; rerun later
rather than treating an empty dataset as valid market evidence.

### FAQ

#### Does this Actor return completed trades?

No. It returns current visible buy and sell orders. Listed prices are not guaranteed transaction
prices.

#### Does it support Riven mod valuation?

This release targets ordinary catalog mods and their item-order endpoints. It does not claim
free-form Riven attribute appraisal.

#### Can I schedule it for price history?

Yes. Schedule consistent inputs and retain each run's dataset downstream. The Actor supplies
observation timestamps but does not merge history across runs.

#### Are price summaries global across all ranks?

No. They are calculated for the exact rank on each output row, after your side, activity, rank,
and visibility filters.

#### Are trader reputation and activity always present?

They are exported when the public source exposes them. Upstream fields can be null or change.

#### Can I request all marketplace items?

The product is intentionally scoped to catalog-selected mods. `maxMods`, `maxOrdersPerMod`, and
`maxItems` provide bounded exports rather than an unbounded marketplace crawl.

# Actor input Schema

## `itemNames` (type: `array`):

Exact Warframe Market mod names or slugs, for example Serration or primed\_continuity. Names are matched case-insensitively.

## `searchQuery` (type: `string`):

Optional text contained in the mod name or slug, such as primed. Use this for catalog discovery.

## `tags` (type: `array`):

Only include items containing every tag. The default mod tag excludes non-mod marketplace items. Examples include rare, legendary, rifle, and warframe.

## `orderTypes` (type: `array`):

Include current sell orders, buy orders, or both.

## `userStatuses` (type: `array`):

Only include orders from users with these current public activity statuses. Use an empty list to include offline users too.

## `ranks` (type: `array`):

Optional exact rank filter. Leave empty to return all listed ranks.

## `maxMods` (type: `integer`):

Maximum number of catalog mods whose orders will be fetched.

## `maxOrdersPerMod` (type: `integer`):

Maximum selected orders exported for each matched mod after filters are applied.

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

Hard limit on order records saved across all matched mods.

## Actor input object example

```json
{
  "itemNames": [
    "Serration"
  ],
  "tags": [
    "mod"
  ],
  "orderTypes": [
    "sell",
    "buy"
  ],
  "userStatuses": [
    "ingame",
    "online"
  ],
  "maxMods": 5,
  "maxOrdersPerMod": 20,
  "maxItems": 20
}
```

# Actor output Schema

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

Default dataset view containing normalized current mod order records.

# 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 = {
    "itemNames": [
        "Serration"
    ],
    "maxOrdersPerMod": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/warframe-market-mod-prices").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 = {
    "itemNames": ["Serration"],
    "maxOrdersPerMod": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/warframe-market-mod-prices").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 '{
  "itemNames": [
    "Serration"
  ],
  "maxOrdersPerMod": 20,
  "maxItems": 20
}' |
apify call automation-lab/warframe-market-mod-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/warframe-market-mod-prices"
        }
    }
}
```

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/u3Q5fUGxEbS5seuBN/builds/b0ppevQMFMvIM8X6l/openapi.json