# Valorant Game Content Scraper (`parseforge/valorant-game-content-scraper`) Actor

Export Valorant game assets: agents, maps, weapons, skins, sprays, gun buddies, player cards / titles, seasons, competitive tiers, and game modes. Pull display names, icons, descriptions, and metadata in 17 languages.

- **URL**: https://apify.com/parseforge/valorant-game-content-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, Videos, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 result items

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)

## 🎮 Valorant Game Content Scraper

> 🚀 **Export the live Valorant game catalog in seconds.** Pull **agents, maps, weapons, weapon skins, sprays, gun buddies, player cards, player titles, seasons, competitive tiers, and game modes** in 18 languages. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-22 · **📊 31 fields** per record · **🎮 11 resource types** · **🌍 18 languages** · **🤖 Live content sync**

The **Valorant Game Content Scraper** exports the Riot Games Valorant content catalog and returns up to **31 fields per record**, including display name, full description, image and splash art, agent abilities and roles, map callouts and coordinates, weapon stats and shop pricing, skin chromas and levels, season dates, and competitive tier metadata. The underlying source is one of the most widely cited unofficial Valorant references and is updated within hours of every Riot game patch.

The catalog covers **11 resource types** spanning playable agents, official maps with full callout data, weapons with full stat sheets, weapon skins with all chromas and levels, sprays, gun buddies, player cards and titles, seasons, competitive tiers, and game modes, all available in **18 game languages**. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes. All filters run server-side, so you skip the parser engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Esports tool builders, game-stat sites, fan content creators, Valorant streamers, third-party app developers, tournament organizers, content aggregators, AI gaming assistants | Agent picker tools, map callout overlays, skin tracker apps, esports stat dashboards, content-creator wikis, fan tier lists, multilingual fan sites |

---

### 📋 What the Valorant Game Content Scraper does

Two filtering workflows in a single run:

- 📚 **Resource-type filter.** Pick one of 11 Valorant asset collections: agents, maps, weapons, weapon skins, sprays, gun buddies, player cards, player titles, seasons, competitive tiers, game modes.
- 🌍 **Language filter.** Pick one of 18 game languages: English (US), Arabic, German, Spanish (Spain), Spanish (Mexico), French, Indonesian, Italian, Japanese, Korean, Polish, Portuguese (Brazil), Russian, Thai, Turkish, Vietnamese, Chinese (Simplified), Chinese (Traditional).

Each record returns the fields appropriate to the resource type. Agents include display icon, abilities, voice line, role, and character tags. Maps include splash art, minimap, callouts with coordinates, and tactical / narrative descriptions. Weapons include full stats and shop pricing. Skins include chromas and progression levels. Seasons include start and end timestamps. Every record carries a UUID for joining with the live game client.

> 💡 **Why it matters:** Valorant is one of the most-watched competitive shooters in esports, with content updates every two weeks. Building your own pipeline means crawling 11 endpoints and tracking patch cycles. This Actor flattens all of that into a unified, multilingual dataset.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded Valorant dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>resourceType</code></td><td>string</td><td><code>"agents"</code></td><td>One of 11 Valorant asset collections.</td></tr>
<tr><td><code>language</code></td><td>string</td><td><code>"en-US"</code></td><td>One of 18 supported languages. Riot language tag (e.g. <code>ja-JP</code>, <code>ko-KR</code>).</td></tr>
</tbody>
</table>

**Example: every playable agent in Japanese.**

```json
{
    "maxItems": 50,
    "resourceType": "agents",
    "language": "ja-JP"
}
````

**Example: 100 weapon skins in Korean.**

```json
{
    "maxItems": 100,
    "resourceType": "skins",
    "language": "ko-KR"
}
```

> ⚠️ **Good to Know:** field availability varies by resource type. Agents populate `abilities` and `role`; maps populate `callouts`, `coordinates`, and `splash`; weapons populate `weaponStats` and `shopData`; skins populate `chromas` and `levels`. Fields not relevant to the resource type are simply omitted from the output.

***

### 📊 Output

Each record contains up to **31 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema (key fields)

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://media.valorant-api.com/agents/dade69b4-.../displayicon.png"` |
| 🏷️ `displayName` | string | `"Jett"` |
| 🔖 `uuid` | string | `"add6443a-41bd-e414-f6ad-e58d267f4e95"` |
| 📚 `resourceType` | string | `"agents"` |
| 📝 `description` | string | `"Representing her home country..."` |
| 🛠️ `developerName` | string | `"Wushu"` |
| 🏷️ `characterTags` | array | `["Korean", "Duelist"]` |
| 📂 `category` | string | `"EEquippableCategory::Sidearm"` |
| 🎭 `role` | object | `{"displayName": "Duelist"}` |
| ✅ `isPlayableCharacter` | boolean | `true` |
| 🎨 `isBaseContent` | boolean | `true` |
| 🪄 `abilities` | array | `[{slot, name, description, icon}]` |
| 🗣️ `voiceLine` | object | voice line metadata |
| 📍 `coordinates` | string | `"36.10°N 138.25°E"` |
| ⚔️ `tacticalDescription` | string | `"A mid-sized map..."` |
| 📖 `narrativeDescription` | string | `"Off the coast of..."` |
| 🗺️ `mapUrl` | string | minimap URL |
| 🖼️ `splash` | string | splash art URL |
| 📌 `callouts` | array | callout zones with regions |
| 📊 `weaponStats` | object | full weapon stat sheet |
| 💰 `shopData` | object | `{cost, category, gridPosition}` |
| 🎨 `skins` | array | per-skin variants |
| 🌈 `chromas` | array | color variants |
| 🎯 `levels` | array | progression levels |
| 📅 `releaseDate` | ISO 8601 | null | `"2020-06-02T00:00:00Z"` |
| 🌍 `language` | string | `"en-US"` |
| 🔗 `detailUrl` | string | source URL |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🎮 Duelist agent: Jett</strong></summary>

```json
{
    "imageUrl": "https://media.valorant-api.com/agents/add6443a-41bd-e414-f6ad-e58d267f4e95/displayicon.png",
    "displayName": "Jett",
    "uuid": "add6443a-41bd-e414-f6ad-e58d267f4e95",
    "resourceType": "agents",
    "description": "Representing her home country of South Korea, Jett's agile and evasive fighting style lets her take risks no one else can.",
    "developerName": "Wushu",
    "characterTags": ["Korean", "Duelist"],
    "role": {"displayName": "Duelist", "description": "Duelists are self-sufficient fraggers."},
    "isPlayableCharacter": true,
    "isBaseContent": true,
    "abilities": [
        {"slot": "Ability1", "displayName": "Cloudburst", "description": "INSTANTLY throw a projectile that expands into a brief vision-blocking cloud."},
        {"slot": "Ability2", "displayName": "Updraft", "description": "INSTANTLY propel Jett high into the air."},
        {"slot": "Grenade", "displayName": "Tailwind", "description": "Prepare a wind current. RE-USE the ability to dash a short distance."},
        {"slot": "Ultimate", "displayName": "Blade Storm", "description": "Equip a set of highly accurate throwing knives."}
    ],
    "voiceLine": null,
    "language": "en-US",
    "detailUrl": "https://valorant-api.com/v1/agents/add6443a-41bd-e414-f6ad-e58d267f4e95",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🗺️ Tactical map: Haven</strong></summary>

```json
{
    "imageUrl": "https://media.valorant-api.com/maps/2bee0dc9-4ffe-519b-1cbd-7fbe763a6047/displayicon.png",
    "displayName": "Haven",
    "uuid": "2bee0dc9-4ffe-519b-1cbd-7fbe763a6047",
    "resourceType": "maps",
    "coordinates": "27.7172° N, 85.3240° E",
    "tacticalDescription": "Watch your back. With three sites to defend, the enemy can launch an attack from many angles.",
    "narrativeDescription": "Off the coast of Bhutan, lies a buried Radianite world. With its dangerous prospects, Haven attracts a particular kind of attention.",
    "mapUrl": "https://media.valorant-api.com/maps/2bee0dc9-.../displayicon.png",
    "splash": "https://media.valorant-api.com/maps/2bee0dc9-.../splash.png",
    "callouts": [
        {"regionName": "A Site", "superRegionName": "Bombsite A", "location": {"x": -2500, "y": 4600}},
        {"regionName": "Mid", "superRegionName": "Middle", "location": {"x": 0, "y": 0}}
    ],
    "language": "en-US",
    "detailUrl": "https://valorant-api.com/v1/maps/2bee0dc9-4ffe-519b-1cbd-7fbe763a6047",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔫 Weapon: Vandal</strong></summary>

```json
{
    "imageUrl": "https://media.valorant-api.com/weapons/9c82e19d-4575-0200-1a81-3eacf00cf872/displayicon.png",
    "displayName": "Vandal",
    "uuid": "9c82e19d-4575-0200-1a81-3eacf00cf872",
    "resourceType": "weapons",
    "category": "EEquippableCategory::Rifle",
    "weaponStats": {
        "fireRate": 9.75,
        "magazineSize": 25,
        "runSpeedMultiplier": 0.92,
        "equipTimeSeconds": 1.0,
        "damageRanges": [{"rangeStartMeters": 0, "rangeEndMeters": 50, "headDamage": 160, "bodyDamage": 40, "legDamage": 34}]
    },
    "shopData": {"cost": 2900, "category": "Rifles"},
    "skins": ["RGX 11z Pro Vandal", "Prime Vandal", "..."],
    "language": "en-US",
    "detailUrl": "https://valorant-api.com/v1/weapons/9c82e19d-4575-0200-1a81-3eacf00cf872",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎮 | **Live game catalog.** 11 resource types covering every public Valorant asset. |
| 🌍 | **18 languages.** From English and Korean to Arabic, Thai, Vietnamese, and both Chinese variants. |
| 🪄 | **Rich agent data.** Full ability lists, roles, character tags, and voice line metadata. |
| 🗺️ | **Map intelligence.** Splash art, minimaps, full callout zones with coordinates. |
| 🔫 | **Weapon stats.** Fire rate, damage ranges, magazine size, run-speed multiplier. |
| ⚡ | **Fast.** 10 records in under 5 seconds, the full catalog in under a minute. |
| 🚫 | **No authentication.** Works with the public Valorant content source. No login or Riot account needed. |

> 📊 Clean, structured Valorant content data is the foundation of every fan wiki, agent picker, map overlay, and esports stat dashboard.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Valorant Game Content Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **11 resource types, 18 languages** | **Live per run** | resource, language | ⚡ 2 min |
| Manual fan wiki copy-paste | Free | Whatever you transcribe | Manual | None | 🐌 Weeks |
| Building your own scraper | Free | Full | Live | Build your own | 🕒 Days of engineering |
| Closed esports content APIs | $50+/month | Often gated, subset | Vendor-controlled | Limited | 🐢 Days |

Pick this Actor when you want the live Valorant catalog flattened into a clean dataset with zero parser maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Valorant Game Content Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a resource type and language, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎮 Fan Tools & Community Apps

- Agent picker with abilities and roles
- Map overlay tools with callouts and coordinates
- Skin tracker apps with chroma and level previews
- Multilingual community apps in 18 languages

</td>
<td width="50%" valign="top">

#### 🏆 Esports & Stat Dashboards

- Tournament stat overlays with agent metadata
- Map-veto helper tools with map data
- Pro-team stat-card generators
- Patch-note diff dashboards across content updates

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📺 Content Creators & Streamers

- Stream overlays with current agent and map info
- Video research databases for analysis content
- Localized streamer wikis in any of 18 languages
- Highlight-reel metadata enrichment

</td>
<td width="50%" valign="top">

#### 🤖 AI Gaming Assistants

- Grounded retrieval source for Valorant chatbots
- Coach-bot prompt grounding with agent abilities
- Build-recommendation engines using weapon stats
- LLM agents that answer game-mechanics questions

</td>
</tr>
</table>

***

### 🔌 Automating Valorant Game Content Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A bi-weekly schedule (aligned with Valorant's patch cycle) keeps downstream databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Esports analytics studies and game-design papers
- Computational analyses of weapon balance
- Reproducible studies with cited patch-day snapshots
- Multilingual content localization research

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, hobbyist stat trackers, indie tools
- Personal practice plans with agent and map data
- Fan content for YouTube, TikTok, and Twitch
- Hobbyist databases for collectors and theorycrafters

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Community-tournament organizing tools
- Educational esports programs for schools
- Inclusion-focused multilingual fan sites
- University and college esports clubs

</td>
<td width="50%">

#### 🧪 Experimentation

- Train agent-pick or composition ML models
- Validate fan-tool product hypotheses with real data
- Prototype LLM agents that play or coach Valorant
- Test localization workflows across 18 languages

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Valorant%20Game%20Content%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Valorant%20Game%20Content%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Valorant%20Game%20Content%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Valorant%20Game%20Content%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a resource type and language in the input form, click Start, and the Actor fetches the latest Valorant catalog and emits a clean structured record per item. No browser automation, no captchas, no setup.

#### 🔄 How often is the dataset refreshed?

The catalog is updated within hours of every Valorant patch (typically every two weeks). Every run of this Actor fetches the latest data.

#### 🪄 Does it include ability icons and splash art?

Yes. Agents include displayIcon and ability icons. Maps include splash art and minimaps. Skins include chromas and progression-level visuals.

#### 🗺️ What languages are supported?

18 languages: English (US), Arabic, German, Spanish (Spain), Spanish (Mexico), French, Indonesian, Italian, Japanese, Korean, Polish, Portuguese (Brazil), Russian, Thai, Turkish, Vietnamese, Chinese (Simplified), and Chinese (Traditional).

#### 🔫 Are weapon stats included?

Yes. Weapons populate `weaponStats` with fire rate, magazine size, run-speed multiplier, equip time, and damage ranges (by body zone and range bucket). `shopData` includes in-game cost and category.

#### ⏰ Can I schedule regular runs?

Yes. A bi-weekly Apify Schedule aligns with Valorant's patch cadence, so you always have the latest balance changes and new content.

#### ⚖️ Is this data legal to use?

The Valorant content catalog is widely used by fan tools, wikis, and content creators. Riot Games maintains terms for fan content; review the Riot Games Legal Jibber Jabber for your specific use case.

#### 💼 Can I use this data commercially?

Riot Games has historically allowed fan content under its policy. Commercial use (esports tools, paid apps) requires reviewing Riot's developer and fan-content terms. You are responsible for compliance.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Valorant Game Content Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe Valorant data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh Valorant data into your stat-tracker backend, or alert your team in Slack on patch day.

***

### 🔗 Recommended Actors

- [**🐉 D\&D 5e SRD Content Scraper**](https://apify.com/parseforge/dnd5e-srd-spells-scraper) - Canonical D\&D 5e rules content
- [**🐲 Open5e SRD Scraper**](https://apify.com/parseforge/open5e-srd-scraper) - Community TTRPG content
- [**📚 Open Library Scraper**](https://apify.com/parseforge/open-library-scraper) - Book metadata and author records
- [**🌐 Wikipedia Article Scraper**](https://apify.com/parseforge/wikipedia-article-scraper) - Structured encyclopedia content
- [**🎓 OpenStax Textbook Scraper**](https://apify.com/parseforge/openstax-scraper) - Open-license academic content

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Riot Games, Inc. Valorant is a trademark of Riot Games, Inc. All trademarks mentioned are the property of their respective owners. Only publicly available game content data is collected. Use of this data must comply with Riot Games' fan content and developer terms.

# Actor input Schema

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

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

## `resourceType` (type: `string`):

Which Valorant asset collection to export.

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

Display language for localized names and descriptions.

## Actor input object example

```json
{
  "maxItems": 10,
  "resourceType": "agents",
  "language": "en-US"
}
```

# Actor output Schema

## `overview` (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,
    "resourceType": "agents",
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/valorant-game-content-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,
    "resourceType": "agents",
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/valorant-game-content-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,
  "resourceType": "agents",
  "language": "en-US"
}' |
apify call parseforge/valorant-game-content-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Valorant Game Content Scraper",
        "description": "Export Valorant game assets: agents, maps, weapons, skins, sprays, gun buddies, player cards / titles, seasons, competitive tiers, and game modes. Pull display names, icons, descriptions, and metadata in 17 languages.",
        "version": "1.0",
        "x-build-id": "CzRQzt1pg6e9JHZnZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~valorant-game-content-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-valorant-game-content-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~valorant-game-content-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-valorant-game-content-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~valorant-game-content-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-valorant-game-content-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",
                "properties": {
                    "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"
                    },
                    "resourceType": {
                        "title": "Resource Type",
                        "enum": [
                            "agents",
                            "maps",
                            "weapons",
                            "skins",
                            "sprays",
                            "buddies",
                            "playercards",
                            "playertitles",
                            "seasons",
                            "competitivetiers",
                            "gamemodes"
                        ],
                        "type": "string",
                        "description": "Which Valorant asset collection to export."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en-US",
                            "ar-AE",
                            "de-DE",
                            "es-ES",
                            "es-MX",
                            "fr-FR",
                            "id-ID",
                            "it-IT",
                            "ja-JP",
                            "ko-KR",
                            "pl-PL",
                            "pt-BR",
                            "ru-RU",
                            "th-TH",
                            "tr-TR",
                            "vi-VN",
                            "zh-CN",
                            "zh-TW"
                        ],
                        "type": "string",
                        "description": "Display language for localized names and descriptions."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
