# Fortnite Item Shop Scraper (`automation-lab/fortnite-item-shop-catalog`) Actor

Export current Fortnite item-shop offers with V-Bucks prices, cosmetics, bundles, images, availability windows, shop sections, and snapshot provenance.

- **URL**: https://apify.com/automation-lab/fortnite-item-shop-catalog.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 $0.63 / 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

## Fortnite Item Shop Scraper

Export the **Fortnite item shop** as structured, offer-level records for rotation monitoring, gaming analytics, publishing workflows, and data pipelines. Each row includes the offer ID, current and regular V-Bucks price, included cosmetics, bundle details, images, availability dates, shop section, and snapshot provenance.

The Actor reads the public Fortnite-API current-shop endpoint. It needs no Fortnite account, Epic Games login, API key, browser, or proxy.

### What does Fortnite Item Shop Scraper do?

The Actor takes one current shop snapshot and converts every matching offer into a stable dataset row.

It can:

- export current offers and bundles;
- find offers by item, bundle, section name, or source ID;
- filter cosmetics by type or rarity;
- isolate discounted offers;
- localize source names and descriptions;
- limit output for inexpensive tests;
- preserve source snapshot hashes and timestamps;
- support recurring runs that can be compared downstream.

The output is offer-level. A bundle is one row with its included item IDs and detailed `items` array, rather than several rows that lose the bundle price relationship.

### Who is it for?

#### Gaming analysts

Build dated shop snapshots and compare price, rarity, and assortment changes.

#### Fortnite creators and publishers

Feed current offers, images, and availability windows into editorial calendars, websites, bots, or daily summaries.

#### Market and product researchers

Measure virtual-goods assortment, bundle composition, discounting, and rotation patterns.

#### Data engineers

Schedule a Task and send clean JSON rows to Google Sheets, a warehouse, webhook, or another Actor.

### Why use offer-level Fortnite shop data?

A cosmetic by itself does not explain how it is being sold. The shop offer supplies the commercial context:

- the final V-Bucks price;
- the regular price and calculated discount;
- bundle membership;
- all included item identifiers;
- the section in which the offer appears;
- the offer's disclosed start and end time;
- the source snapshot identifier.

Keeping these fields together makes recurring comparisons less ambiguous.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `offerId` | Stable shop offer identifier |
| `offerName` | Bundle name or combined included-item names |
| `offerKind` | `bundle`, `cosmetic`, `car`, `track`, `instrument`, `banner`, or `other` |
| `regularPrice` | Regular price in V-Bucks |
| `finalPrice` | Current price in V-Bucks |
| `discountAmount` | Regular price minus final price |
| `discountPercent` | Calculated percentage discount |
| `inDate`, `outDate` | Source-disclosed availability window |
| `giftable`, `refundable` | Offer flags disclosed by the source |
| `sectionId`, `sectionName` | Shop layout identity and label |
| `bundleName`, `bundleInfo` | Bundle metadata when applicable |
| `imageUrl` | Best available bundle, display, or item image |
| `itemIds`, `itemNames` | Included product identities |
| `itemTypes`, `rarities` | Distinct normalized classifications |
| `items` | Detailed included-item objects |
| `snapshotHash`, `snapshotDate` | Provenance for comparing scheduled runs |
| `sourceUrl`, `extractedAt` | Retrieval source and Actor extraction time |

Item objects may also contain description, display type, rarity display name, series, set, introduction text, added date, and image URL. Fields absent from the public source are `null`, not guessed.

### Getting started

1. Open the Actor input form.
2. Leave `language` as English or select another supported localization.
3. Remove the prefilled `query` to export the broad current shop, or enter text such as `bundle`.
4. Add optional item-type, rarity, or section filters.
5. Choose a `maxItems` value from 1 to 500.
6. Click **Start**.
7. Open the default dataset to preview or download the rows.
8. Save the run as an Apify Task if you want recurring snapshots.

A first test with `query: "bundle"` and `maxItems: 50` normally returns current bundle offers while keeping the run small.

### Input parameters

#### `language`

Localization passed to Fortnite-API. The default is `en`. Supported values are Arabic, German, English, Spanish, Latin American Spanish, French, Italian, Japanese, Korean, Polish, Brazilian Portuguese, Russian, Turkish, Simplified Chinese, and Traditional Chinese.

#### `query`

Optional case-insensitive text search. It matches offer names, bundle names, item names and IDs, and shop section labels. It does not perform fuzzy matching or generate suggestions.

#### `itemTypes`

Optional exact source values such as:

- `outfit`
- `pickaxe`
- `glider`
- `emote`
- `backpack`
- `music`

An offer is accepted when at least one included item has a selected type.

#### `rarities`

Optional exact rarity or series values such as `uncommon`, `rare`, `epic`, `legendary`, `marvel`, or `gaminglegends`.

#### `sectionNames`

Optional text fragments matched against section ID, name, and category. Because section names rotate, inspect a broad snapshot before creating a long-lived section filter.

#### `onlyDiscounted`

Keep only offers whose final price is lower than their regular price.

#### `maxItems`

Maximum matching offers to save. Allowed range: 1–500. If fewer current offers match, the Actor returns the naturally smaller dataset.

### Example inputs

#### Find current bundles

```json
{
  "language": "en",
  "query": "bundle",
  "maxItems": 50
}
```

#### Export a broad current snapshot

```json
{
  "language": "en",
  "maxItems": 100
}
```

#### Monitor outfit rotations

```json
{
  "language": "en",
  "itemTypes": ["outfit"],
  "maxItems": 100
}
```

#### Find discounted rare offers

```json
{
  "language": "en",
  "rarities": ["rare"],
  "onlyDiscounted": true,
  "maxItems": 100
}
```

Filters are combined with AND. Values inside one array use OR: an offer containing either selected item type can match.

### Output example

A shortened real output shape looks like this:

```json
{
  "offerId": "v2:/a061e9619bb69442be67b956323f237c712e865b19e31dbbbe65e4ba9d573098",
  "offerName": "The Batman Who Laughs Bundle",
  "offerKind": "bundle",
  "regularPrice": 3100,
  "finalPrice": 2200,
  "discountAmount": 900,
  "discountPercent": 29.03,
  "currency": "V-Bucks",
  "inDate": "2026-09-05T00:00:00Z",
  "outDate": "2026-09-10T23:59:59.999Z",
  "sectionName": "DC",
  "bundleName": "The Batman Who Laughs Bundle",
  "itemCount": 4,
  "itemIds": ["CID_A_223_Athena_Commando_M_Grasshopper"],
  "itemNames": ["The Batman Who Laughs"],
  "snapshotHash": "1c355ec66d29f44a",
  "snapshotDate": "2026-09-08T00:00:00Z",
  "language": "en",
  "sourceUrl": "https://fortnite-api.com/v2/shop?language=en"
}
```

The live row contains the complete `items` array and image/provenance fields. Values change with the Fortnite shop rotation.

### How much does it cost to export Fortnite item shop offers?

The Actor uses pay-per-event pricing:

- one `start` charge when a valid run begins;
- one `item` charge for each offer saved to the default dataset;
- no item charge for source entries rejected by filters or duplicate IDs.

The applicable item price depends on your Apify account tier. The one-time start price is $0.001. Current per-offer prices are:

| Tier | Price per saved offer |
| --- | ---: |
| FREE | $0.0012014 |
| BRONZE | $0.0010447 |
| SILVER | $0.00081488 |
| GOLD | $0.00062683 |
| PLATINUM | $0.00062683 |
| DIAMOND | $0.00062683 |

At BRONZE pricing:

| Saved offers | Example total |
| ---: | ---: |
| 10 | $0.011447 |
| 100 | $0.10547 |
| 300 | $0.31441 |

These are Actor-event examples, not the V-Bucks value of the shop contents. The current shop is finite, so setting `maxItems: 500` does not manufacture 500 rows.

### Build a Fortnite shop rotation monitor

Apify scheduling turns the current-only source into a sequence of your own dated snapshots:

1. Save a broad input as an Apify Task.
2. Schedule it daily after the expected shop refresh.
3. Export each dataset to persistent storage or a warehouse.
4. Join rows on `offerId`.
5. Compare `snapshotHash`, `inDate`, `outDate`, price, and included item IDs.
6. Trigger your own alert or publishing flow when differences appear.

The Actor does not claim that Fortnite-API exposes a historical archive. History comes from the snapshots you schedule and retain.

### Integration ideas

#### Google Sheets

Use the Google Sheets integration to append offer rows for editorial planning or assortment analysis.

#### Webhooks

Add a run-succeeded webhook that starts a comparison Actor or notifies your service that a new snapshot is available.

#### Warehouses and BI

Download JSON, JSONL, CSV, XML, Excel, or RSS from the dataset API. Preserve nested `items` as JSON when your warehouse supports it.

#### Content pipelines

Filter a creator-relevant item type, then map names, prices, images, and `outDate` into a daily content queue.

### API usage with cURL

Start a run and wait for the dataset response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fortnite-item-shop-catalog/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"language":"en","query":"bundle","maxItems":50}'
```

Keep tokens in environment variables or a secret manager. Do not commit them to source control.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fortnite-item-shop-catalog').call({
    language: 'en',
    itemTypes: ['outfit'],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/fortnite-item-shop-catalog").call(
    run_input={"language": "en", "maxItems": 100}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add Apify MCP to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fortnite-item-shop-catalog"
```

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

Claude Desktop, Cursor, and VS Code can use this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fortnite-item-shop-catalog"
    }
  }
}
```

Example prompts:

- “Run the Fortnite Item Shop Scraper for English bundles and return their V-Bucks prices.”
- “Export current Fortnite outfits with rarity, images, and availability end dates.”
- “Compare this dataset with yesterday's retained shop snapshot by offer ID.”

The comparison in the last prompt requires both datasets to be available to the calling workflow.

### Reliability and retry behavior

The Actor uses one anonymous HTTPS request to a public structured endpoint. It validates status, content type, and response shape before emitting data.

Network errors, HTTP 429, and HTTP 5xx responses receive up to three total attempts with short exponential backoff. Deterministic errors and malformed source responses fail the run instead of silently returning misleading output.

No browser assets or image files are downloaded. Image URLs are saved as metadata, reducing runtime and transfer.

### Limits and important details

- The source is a third-party community API, not Epic Games.
- Output reflects the source's current snapshot at run time.
- The Actor does not provide past rotations unless you scheduled and retained them.
- Source fields can be absent; optional output is then `null` or an empty array.
- Item types and rarity values are source-controlled and can evolve.
- A text or section filter can naturally return zero rows.
- `maxItems` limits accepted offers, not raw source entries.
- No account, cookies, proxy, or residential traffic is used.

### Responsible use and legality

The Actor accesses public catalog metadata from Fortnite-API. Review that service's terms and attribution expectations, Epic Games' policies, and the rules that apply to your use case.

Do not imply endorsement by Epic Games, sell copyrighted images as your own, or use output for deceptive offers. Store only the data you need and respect takedown or licensing requirements for downstream publishing.

Fortnite is a trademark of Epic Games. This Actor is an independent data tool and is not affiliated with or endorsed by Epic Games.

### Troubleshooting

#### The dataset is empty

Remove `query`, `sectionNames`, `rarities`, and `itemTypes`, then test a broad snapshot. A rotating section or specific item may no longer be in the current shop.

#### A type or rarity filter returns no rows

Use values exposed in a recent broad run. Filters use exact source values, case-insensitively.

#### The run fails after retries

Check the run log for the upstream HTTP status or response-shape error. Retry later rather than adding a proxy; the Actor does not expose a proxy mode because the public API normally works directly.

#### Why are there fewer rows than `maxItems`?

`maxItems` is a ceiling. The current shop or your filters may contain fewer matching offers.

#### Why did two runs have the same snapshot hash?

The upstream catalog had not changed between runs. Use both `snapshotHash` and `snapshotDate` when evaluating rotations.

### FAQ

#### Does this scrape the in-game client?

No. It normalizes the public Fortnite-API current-shop JSON response.

#### Does it need my Fortnite login?

No. Never provide Epic Games credentials to this Actor.

#### Can it return Turkish or Japanese names?

Yes. Select `tr` or `ja` in `language`. Availability of localized text depends on the source record.

#### Does one included cosmetic cost one item event?

No. The charged `item` event represents one saved shop offer row. Included cosmetics are nested in that row without a separate event charge.

#### Can it monitor newly added items?

Scheduled snapshots preserve each item's `addedAt` metadata when available and let your downstream process identify newly appearing offer IDs.

#### Can it download images?

It returns public image URLs. It intentionally does not download image binaries.

### Related Automation Lab Actors

- [Steam Games Sale Prices Scraper](https://apify.com/automation-lab/steam-game-sale-price-tracker) — track regional Steam prices and discounts.
- [Google Play Apps Scraper](https://apify.com/automation-lab/google-play-app-catalog-details) — export app catalog and detail metadata.

Choose this Actor when the job is specifically current Fortnite virtual-goods offers and rotations. Choose the Steam Actor for PC game storefront sale tracking, or the Google Play Actor for mobile app catalogs.

### Support

If a current broad snapshot fails repeatedly, open an Actor issue with the run URL, non-secret input, expected behavior, and a short description of the missing or incorrect field. Do not include API tokens or account credentials.

# Actor input Schema

## `language` (type: `string`):

Language used by Fortnite-API for localized cosmetic names and descriptions.

## `query` (type: `string`):

Optional case-insensitive text matched against offer, bundle, item, and shop-section names or IDs.

## `itemTypes` (type: `array`):

Optional exact source type values, such as outfit, pickaxe, glider, emote, backpack, or music.

## `rarities` (type: `array`):

Optional exact source rarity values, such as uncommon, rare, epic, legendary, marvel, or gaminglegends.

## `sectionNames` (type: `array`):

Optional case-insensitive fragments matched against shop section ID, name, or category.

## `onlyDiscounted` (type: `boolean`):

When enabled, keep offers whose final V-Bucks price is lower than the regular price.

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

Maximum number of matching offer records to save. The current shop is finite; no synthetic results are added.

## Actor input object example

```json
{
  "language": "en",
  "query": "bundle",
  "itemTypes": [],
  "rarities": [],
  "sectionNames": [],
  "onlyDiscounted": false,
  "maxItems": 20
}
```

# Actor output Schema

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

Open the default dataset in the offer-focused overview 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 = {
    "language": "en",
    "query": "bundle",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fortnite-item-shop-catalog").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 = {
    "language": "en",
    "query": "bundle",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fortnite-item-shop-catalog").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 '{
  "language": "en",
  "query": "bundle",
  "maxItems": 20
}' |
apify call automation-lab/fortnite-item-shop-catalog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fortnite-item-shop-catalog"
        }
    }
}

```

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/dIvyJa8KAAjE4aYGu/builds/0GRVGoFvLLCE18ZcW/openapi.json