# Gemini Crypto Exchange Scraper (`parseforge/gemini-tickers-scraper`) Actor

Scrape live price feed from Gemini, a US-regulated exchange. Pair, price, percent change 24h for all available spot pairs. No API key required.

- **URL**: https://apify.com/parseforge/gemini-tickers-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.15 / 1,000 results

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)

## 🌌 Gemini Crypto Exchange Scraper

> 🚀 **Export the full Gemini market list in seconds.** Pull live pricing, 24h change, bid, ask, spread, and 24h volume across **400+ spot pairs and 10+ perpetual contracts** from the US-regulated Gemini exchange. No API key, no signup, no rate-limit guesswork.

> 🕒 **Last updated:** 2026-05-13 · **📊 15 fields** per record · **🪙 400+ spot pairs** · **🔁 10+ perpetuals** · **🌐 13 quote currencies**

The **Gemini Tickers Scraper** queries Gemini's public price-feed and per-pair ticker endpoints and returns **15 fields per record**, including the pair, base and quote assets, perpetual flag, last price, percent change 24h, bid, ask, absolute and basis-point spreads, and 24h volume in both base and quote currency. Gemini is a US-regulated exchange known for compliance-friendly trading and a wide stablecoin lineup (USD, USDC, USDT, GUSD, RLUSD, PYUSD, DAI).

The catalog covers **all live pairs on Gemini**, spanning spot books quoted in fiat (USD, EUR, GBP, SGD), six major stablecoins, and crypto bases (BTC, ETH, SOL), plus a small set of perpetual contracts identified by a `PERP` suffix. This Actor turns the two-step Gemini API (one bulk feed + per-pair pubticker) into a single dataset. Export it as CSV, Excel, JSON, or XML in under a minute. Filtering and sorting run server-side.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| US-based crypto traders, compliance-aware desks, stablecoin analysts, quant teams, fintech apps, treasury managers | Regulated-venue price tracking, stablecoin spread analysis, perp vs spot basis monitoring, top-volume leaderboards, audit-ready snapshots |

---

### 📋 What the Gemini Scraper does

Four filtering workflows in a single run:

- 🌐 **All-pairs snapshot.** Every live Gemini pair, with perpetuals automatically flagged.
- 💵 **Quote filter.** Restrict to any of 13 quote assets (USD, USDC, USDT, GUSD, RLUSD, PYUSD, EUR, GBP, SGD, BTC, ETH, DAI, SOL).
- 📊 **Detail toggle.** `fetchDetails=true` (default) pulls bid, ask, spread, and 24h volume per pair. Disable for a fast price-only feed.
- 📈 **Sort options.** Order by 24h volume (requires details), percent change, last price, or pair name.

Each record includes the canonical Gemini pair, derived base and quote, a perpetual flag, last price, percent change in percent units (4 decimal places), bid, ask, absolute spread, basis-point spread, and 24h volume in both base and quote currency, plus the volume timestamp.

> 💡 **Why it matters:** Gemini's `pricefeed` returns prices for every pair in one shot, but spread and volume require a separate per-pair `pubticker` call. Building this yourself means orchestrating 400+ requests, splitting non-standard quote names like `RLUSD` and `PYUSD` correctly, and detecting perpetual contracts. This Actor handles all of it.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded 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>quoteAsset</code></td><td>string</td><td><code>""</code></td><td>One of USD, USDC, USDT, GUSD, RLUSD, PYUSD, EUR, GBP, SGD, BTC, ETH, DAI, SOL. Empty = all pairs.</td></tr>
<tr><td><code>sortBy</code></td><td>string</td><td><code>"percentChange24h"</code></td><td>Sort order: <code>volume</code> (needs <code>fetchDetails=true</code>), <code>percentChange24h</code>, <code>price</code>, or <code>pair</code>.</td></tr>
<tr><td><code>fetchDetails</code></td><td>boolean</td><td><code>true</code></td><td>If <code>true</code>, makes one additional call per pair for bid, ask, spread, and 24h volume.</td></tr>
</tbody>
</table>

**Example: top 20 USD pairs by 24h volume with full detail.**

```json
{
    "maxItems": 20,
    "quoteAsset": "USD",
    "sortBy": "volume",
    "fetchDetails": true
}
````

**Example: every pair, fast price-only feed sorted by biggest 24h gainers.**

```json
{
    "maxItems": 100,
    "quoteAsset": "",
    "sortBy": "percentChange24h",
    "fetchDetails": false
}
```

> ⚠️ **Good to Know:** Gemini pairs are concatenated symbols (e.g. `BTCUSD`, `ETHGUSD`). The Actor splits them by matching the longest known quote first, so `RLUSD` is not misread as `USD`. Perpetual contracts carry a `PERP` suffix and are returned in the same dataset with `isPerpetual: true`.

***

### 📊 Output

Each ticker record contains **15 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏷️ `pair` | string | `"BTCUSD"` |
| 🔗 `url` | string | `"https://exchange.gemini.com/buy-sell/BTCUSD"` |
| 🪙 `baseAsset` | string | null | `"BTC"` |
| 💵 `quoteAsset` | string | null | `"USD"` |
| 🔁 `isPerpetual` | boolean | `false` |
| 💲 `lastPrice` | number | null | `0.013097` |
| 📊 `percentChange24hPercent` | number | null | `63.22` |
| 🟢 `bid` | number | null | `79065` |
| 🔴 `ask` | number | null | `79076` |
| 📏 `spreadAbs` | number | null | `11` |
| 📐 `spreadBps` | number | null | `1.39` |
| 📦 `volume24hBase` | number | null | `905.94` |
| 💰 `volume24hQuote` | number | null | `71629318.5` |
| 🕒 `volumeTimestamp` | ISO 8601 | null | `"2026-05-12T22:00:00.000Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>📈 Top mover on the IOTX-USD book</strong></summary>

```json
{
    "pair": "IOTXUSD",
    "url": "https://exchange.gemini.com/buy-sell/IOTXUSD",
    "baseAsset": "IOTX",
    "quoteAsset": "USD",
    "isPerpetual": false,
    "lastPrice": 0.013097,
    "percentChange24hPercent": 63.22,
    "bid": null,
    "ask": null,
    "spreadAbs": null,
    "spreadBps": null,
    "volume24hBase": null,
    "volume24hQuote": null,
    "volumeTimestamp": null,
    "scrapedAt": "2026-05-12T22:54:02.768Z"
}
```

</details>

<details>
<summary><strong>🪙 Same coin against USDC: IOTXUSDC</strong></summary>

```json
{
    "pair": "IOTXUSDC",
    "url": "https://exchange.gemini.com/buy-sell/IOTXUSDC",
    "baseAsset": "IOTX",
    "quoteAsset": "USDC",
    "isPerpetual": false,
    "lastPrice": 0.013097,
    "percentChange24hPercent": 63.22,
    "bid": null,
    "ask": null,
    "spreadAbs": null,
    "spreadBps": null,
    "volume24hBase": null,
    "volume24hQuote": null,
    "volumeTimestamp": null,
    "scrapedAt": "2026-05-12T22:54:02.768Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌐 | **Wide stablecoin coverage.** 13 quote assets including USD, USDC, USDT, GUSD, RLUSD, PYUSD, DAI. |
| 🔁 | **Spot + perpetuals.** Perp contracts auto-detected and flagged with `isPerpetual: true`. |
| 📐 | **Pre-computed spreads.** Absolute and basis-point spreads alongside top of book. |
| ⚡ | **Smart enrichment.** Detail calls only run on the rows that survive your filter and slice, so 10-row runs stay fast. |
| 🔁 | **Always fresh.** Every run hits the Gemini public API live. |
| 🚫 | **No authentication.** Public market data only. No API key, no IP whitelist. |
| 🏛️ | **US-regulated venue.** Compliance-friendly source for treasury and audit use cases. |

> 📊 Gemini is a primary on-ramp for US institutional crypto. Clean ticker data is the starting point for treasury, audit, and risk workflows.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Perp detection | Spreads | Setup |
|---|---|---|---|---|---|
| **⭐ Gemini Tickers Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **400+** pairs | ✅ Built-in | ✅ Built-in | ⚡ 2 min |
| Raw Gemini API | Free | All pairs | Manual | Manual | 🐢 Hours |
| Multi-venue aggregator APIs | $50+/month | Many venues | Mixed | Mixed | ⏳ Days |
| Static market-data dumps | Free | Stale | None | None | 🕒 Variable |

Pick this Actor when you want a clean, server-filtered Gemini snapshot with no infra.

***

### 🚀 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 Gemini Crypto Exchange Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a quote asset (or leave empty for all), choose a sort order, set `maxItems`, decide whether to fetch detail.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the price feed and (optionally) per-pair detail.
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">

#### 🏛️ Treasury and compliance

- Audit-ready price snapshots from a US-regulated venue
- Daily mark-to-market for crypto holdings
- Stablecoin spread monitoring (USDC, GUSD, RLUSD, PYUSD)
- Reference prices for fund admin reporting

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

#### 📈 Quant and trading

- Perp-vs-spot basis for funding-rate strategies
- Top-of-book monitoring on regulated venues
- Cross-stablecoin arbitrage screens
- Liquidity rankings by 24h quote volume

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

#### 📊 Analytics and dashboards

- Top-gainer or top-loser leaderboards by quote
- Stablecoin liquidity heatmaps
- Perp open-interest context dashboards
- Embedded price widgets for fintech UIs

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

#### 🧪 Research and backtesting

- Snapshots for academic finance studies
- Inputs for ML pipelines targeting short-term moves
- Reference series for portfolio backtests
- Stablecoin peg stability analysis

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

***

### 🔌 Automating Gemini Tickers 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. Minute-level snapshots feed dashboards, hourly captures populate data warehouses.

***

### 🌟 Beyond business use cases

Live ticker data powers more than commercial workflows. The same structured records support research, education, and personal projects.

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

#### 🎓 Research and academia

- Stablecoin peg stability studies
- Spread comparison across regulated and unregulated venues
- Teaching datasets for finance and data-science courses
- Reproducible price series for replicable research

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

#### 🎨 Personal and creative

- Personal portfolio trackers and watchlists
- Hobbyist trading bots and learning projects
- Crypto-themed visualizations and infographics
- Open-source dashboards for community sites

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

#### 🤝 Non-profit and civic

- Transparency tooling for crypto charity reserves
- Educational content for financial literacy programs
- Audit support for DAO treasury reporting
- Investigative journalism on stablecoin events

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

#### 🧪 Experimentation

- Prototype perp-basis trading bots
- Test alerting agents that watch spread blowouts
- Validate UI mockups with real ticks
- Run paper-trading simulators on live feeds

</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%20Gemini%20Tickers%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%20Gemini%20Tickers%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%20Gemini%20Tickers%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%20Gemini%20Tickers%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 quote asset, sort order, and `maxItems`, click Start, and the Actor calls Gemini's `pricefeed` for the full pair list, applies your filters server-side, and (when `fetchDetails` is on) makes one extra `pubticker` call per surviving pair for bid, ask, spread, and 24h volume.

#### 📏 How accurate is the data?

The data is the same feed Gemini serves to its trading UI. Prices reflect the moment of the run.

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

Every run pulls live tickers. Schedule a run every minute, every hour, or every day depending on your downstream need.

#### 🛂 Do I need a Gemini account or API key?

No. This Actor only uses public market-data endpoints, which require no authentication.

#### 🔁 Does it include perpetual contracts?

Yes. Perp pairs carry a `PERP` suffix on Gemini and are returned in the same dataset with `isPerpetual: true`. Filter your downstream queries on that flag to separate spot from perps.

#### 📐 What are `spreadAbs` and `spreadBps`?

`spreadAbs` is the absolute bid-ask spread in quote currency units. `spreadBps` is the same spread expressed in basis points of last price, so it's directly comparable across pairs at different price levels.

#### ⚡ Why does `fetchDetails=false` skip some fields?

The bulk `pricefeed` only returns pair, price, and 24h percent change. Bid, ask, spread, and 24h volume require a separate per-pair call. Disable detail when you only need prices and want the run to finish in seconds.

#### ⏰ Can I schedule regular runs?

Yes. Apify Schedules supports any cron interval. A common pattern is one snapshot per minute into a time-series store.

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

Yes. Gemini publishes public market data under standard exchange terms. Review their terms of service for redistribution requirements.

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

Yes. Public market data from a major exchange is widely used in commercial products. Confirm Gemini's API terms cover your specific use case if you plan to redistribute the raw feed.

#### 💳 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 unlocks scheduling and higher concurrency.

#### 🆘 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

Gemini Tickers 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) - Push price alerts into channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe ticker 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 prices into your trading backend, or alert your team in Slack on stablecoin peg breaks.

***

### 🔗 Recommended Actors

- [**📈 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker and adviser registration records
- [**💼 Pitchbook Investors Scraper**](https://apify.com/parseforge/pitchbook-investors-scraper) - Private-market investor profiles
- [**💼 Pitchbook Funds Scraper**](https://apify.com/parseforge/pitchbook-funds-scraper) - PE and VC fund records
- [**🏪 Stripe Marketplace Scraper**](https://apify.com/parseforge/stripe-marketplace-scraper) - Fintech app marketplace catalog
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Corporate and market press releases

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more financial and market-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 Gemini Trust Company, LLC. All trademarks mentioned are the property of their respective owners. Only publicly available market data is collected.

# Actor input Schema

## `quoteAsset` (type: `string`):

Filter pairs by quote asset. Leave empty to return every pair across all quotes.

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

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

## `sortBy` (type: `string`):

Sort results before applying maxItems. Volume sort requires fetchDetails=true.

## `fetchDetails` (type: `boolean`):

Makes one additional call per pair to fetch bid, ask, spread, and 24h volume. Enabled by default. Disable for faster runs when those fields aren't needed.

## Actor input object example

```json
{
  "quoteAsset": "",
  "maxItems": 10,
  "sortBy": "percentChange24h",
  "fetchDetails": true
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "quoteAsset": "",
    "maxItems": 10,
    "sortBy": "percentChange24h"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/gemini-tickers-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 = {
    "quoteAsset": "",
    "maxItems": 10,
    "sortBy": "percentChange24h",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/gemini-tickers-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 '{
  "quoteAsset": "",
  "maxItems": 10,
  "sortBy": "percentChange24h"
}' |
apify call parseforge/gemini-tickers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gemini Crypto Exchange Scraper",
        "description": "Scrape live price feed from Gemini, a US-regulated exchange. Pair, price, percent change 24h for all available spot pairs. No API key required.",
        "version": "0.0",
        "x-build-id": "fchHM0ve11bvUR8Fy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~gemini-tickers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-gemini-tickers-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~gemini-tickers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-gemini-tickers-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~gemini-tickers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-gemini-tickers-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": {
                    "quoteAsset": {
                        "title": "Quote Asset Filter",
                        "enum": [
                            "",
                            "USD",
                            "USDC",
                            "USDT",
                            "GUSD",
                            "RLUSD",
                            "PYUSD",
                            "EUR",
                            "GBP",
                            "SGD",
                            "BTC",
                            "ETH",
                            "DAI",
                            "SOL"
                        ],
                        "type": "string",
                        "description": "Filter pairs by quote asset. Leave empty to return every pair across all quotes.",
                        "default": ""
                    },
                    "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"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "volume",
                            "percentChange24h",
                            "price",
                            "pair"
                        ],
                        "type": "string",
                        "description": "Sort results before applying maxItems. Volume sort requires fetchDetails=true.",
                        "default": "percentChange24h"
                    },
                    "fetchDetails": {
                        "title": "Fetch Detail (bid/ask/volume)",
                        "type": "boolean",
                        "description": "Makes one additional call per pair to fetch bid, ask, spread, and 24h volume. Enabled by default. Disable for faster runs when those fields aren't needed.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
