# Gemini Exchange Prices Scraper (`real-estate-api/gemini-exchange-prices-scraper`) Actor

Gemini Exchange Prices Scraper is a Python tool designed to extract real-time spot prices, order book data, ticker stats, and recent trade history from the Gemini cryptocurrency exchange. It exports structured market datasets into clean CSV or JSON format

- **URL**: https://apify.com/real-estate-api/gemini-exchange-prices-scraper.md
- **Developed by:** [real-estate-api](https://apify.com/real-estate-api) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Gemini Exchange Prices Scraper — Crypto Tickers, Market Rules, and Candles

### Overview

Gemini Exchange Prices Scraper collects publicly available cryptocurrency market data and organizes it into structured dataset records. Choose from ticker snapshots, the trading-pair catalog, symbol details, or OHLC candlestick data.

The actor supports configurable trading pairs, candle intervals, and collection limits. Export the results as JSON, CSV, or Excel through the Apify dataset for market research, price monitoring, and historical charting workflows.

### Features

- **Ticker snapshots:** Collect bid prices, ask prices, last prices, and available trading-volume information.
- **Trading-pair catalog:** Retrieve the available market symbols.
- **Symbol details:** Collect available currency information, tick sizes, minimum order sizes, and trading status.
- **OHLC candles:** Collect open, high, low, and close prices with associated volume.
- **Multiple trading pairs:** Specify symbols such as `btcusd`.
- **Configurable intervals:** Select from supported candlestick timeframes.
- **Duplicate prevention:** Skip duplicate symbols and candle timestamps.
- **Structured dataset:** Save records in a flat format suitable for analysis.
- **Flexible exports:** Download data as JSON, CSV, or Excel.
- **Scheduled snapshots:** Repeat collection to compare market data across different times.

### Use Cases

- **Price monitoring:** Save bid, ask, and last prices for Bitcoin and other available trading pairs.
- **Market discovery:** Retrieve the published symbol catalog to review available markets.
- **Trading-rule research:** Examine price increments, minimum order sizes, and trading status.
- **Historical charting:** Collect hourly or other supported candlesticks for price analysis.
- **Market comparison:** Compare snapshots collected at different times.
- **Research datasets:** Prepare structured market records for Python, Pandas, spreadsheets, or data warehouses.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `symbols` | Array of strings | `["btcusd"]` | Trading-pair symbols used in ticker, details, and candle modes. |
| `mode` | String | `ticker` | Collection mode: `ticker`, `symbols`, `details`, or `candles`. |
| `timeFrame` | String | `1hr` | Candlestick interval used in `candles` mode. |
| `maxItems` | Integer | `100` | Maximum number of rows to save, including failed-lookup rows. Hard maximum: 1,000. |
| `requestDelaySecs` | Number | `1` | Minimum delay between requests, in seconds. |
| `timeoutSecs` | Integer | `300` | Maximum run duration. |
| `requestTimeoutSecs` | Integer | `30` | Maximum wait for an individual response, in seconds. |

#### Example Input

**1. Collect a Bitcoin ticker**

```json id="g4p8kd"
{
  "symbols": ["btcusd"],
  "mode": "ticker",
  "timeFrame": "1hr",
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

**2. Collect the trading-pair catalog**

```json id="h7m2qx"
{
  "symbols": [],
  "mode": "symbols",
  "timeFrame": "1hr",
  "maxItems": 1000,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

**3. Collect symbol details**

```json id="v5n9cb"
{
  "symbols": ["btcusd", "ethusd"],
  "mode": "details",
  "timeFrame": "1hr",
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

**4. Collect hourly candles**

```json id="w2f6ra"
{
  "symbols": ["btcusd"],
  "mode": "candles",
  "timeFrame": "1hr",
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

Supported candle intervals are `1m`, `5m`, `15m`, `30m`, `1hr`, `6hr`, and `1day`, subject to availability.

### What Data Does This Actor Extract?

The actor produces records according to the selected mode. Ticker records contain current market prices and available volume information. Symbol catalog records identify available trading pairs, while details records contain market configuration information. Candle records contain OHLC prices and base volume.

#### Extracted Data Fields

| Field | Type | Description |
|---|---|---|
| `symbol` | String | Trading-pair identifier, such as `btcusd`. |
| `bid` | String | Best bid price reported by the ticker. |
| `ask` | String | Best ask price reported by the ticker. |
| `last` | String | Last trade price reported by the ticker. |
| `volume` | Object | Available volume amounts and associated timestamp. |
| `quote_currency` | String | Quote currency from symbol details, when available. |
| `base_currency` | String | Base currency from symbol details, when available. |
| `tick_size` | Number | Minimum price increment, when provided. |
| `quote_increment` | Number | Quote amount increment, when provided. |
| `min_order_size` | String | Minimum order size, when provided. |
| `symbol_status` | String | Trading status, such as `open`, when provided. |
| `wrap_enabled` | Boolean | Whether wrapping is enabled, when provided. |
| `product_type` | String | Product classification, when available. |
| `contract_type` | String | Contract classification, when available. |
| `contract_price_currency` | String | Contract price currency, when provided. |
| `time_frame` | String | Candlestick interval associated with the record. |
| `candle_time` | Integer | Candle open time in milliseconds. |
| `open_price` | Number | Candle opening price. |
| `high_price` | Number | Highest price during the candle. |
| `low_price` | Number | Lowest price during the candle. |
| `close_price` | Number | Candle closing price. |
| `candle_volume` | Number | Base volume for the candle. |
| `mode` | String | Collection mode: `ticker`, `symbols`, `details`, or `candles`. |
| `scraped_at` | String | UTC timestamp indicating when the record was saved. |

Fields vary by collection mode and by the information available for each trading pair.

#### Example Output

```json id="n6y3tf"
{
  "symbol": "btcusd",
  "bid": "83259.14000",
  "ask": "83259.15000",
  "last": "83264.50000",
  "volume": {
    "BTC": "48.7241862",
    "USD": "4056995.0018499",
    "timestamp": 1791753780000
  },
  "mode": "ticker",
  "scraped_at": "2026-10-12T00:00:00+00:00"
}
```

This example illustrates the ticker output structure. Actual prices, volume amounts, and timestamps vary with market conditions and collection time.

### Working with Your Dataset

When the run completes, open the Apify dataset to inspect and export the results.

- **JSON:** Suitable for structured data processing and application workflows.
- **CSV:** Useful for Pandas, spreadsheet applications, and analytical pipelines.
- **Excel:** Convenient for manual review, filtering, and reporting.

Ticker records can be used to compare bid-ask spreads. Symbol details can support market catalog analysis, while candle records can be transformed into time series for charting and historical research.

Check timestamps, available fields, and trading-pair identifiers before combining records from different modes.

### Important Notes

- The default collection mode is `ticker`, with `btcusd` as the default symbol.
- Supported modes are `ticker`, `symbols`, `details`, and `candles`.
- The `timeFrame` setting applies to candle collection only.
- The maximum number of saved rows is 1,000 per run.
- The configured row limit applies to saved results, including failed-lookup rows.
- The trading-pair catalog and candle responses may contain many records; the configured row limit can restrict the number saved.
- Requests are processed sequentially with a minimum delay of one second.
- Duplicate symbols and duplicate candle timestamps are skipped.
- Some fields may be absent depending on the collection mode or the market information provided.
- Results reflect the information available when the actor runs and are not guaranteed to represent current prices after collection.
- Market availability and supported candle intervals depend on the exchange's published data.
- Cryptocurrency prices are volatile. Collected snapshots are intended for research and analysis, not as guaranteed real-time quotes or investment advice.

### FAQ

**What collection modes are available?**

The actor supports ticker snapshots, the trading-pair catalog, symbol details, and candlestick data.

**Can I collect multiple trading pairs?**

Yes. Supply multiple symbols, such as `btcusd` and `ethusd`, for ticker, details, or candle collection.

**What information is available in ticker mode?**

Ticker records include the available bid, ask, last price, and volume information.

**What does symbol details mode provide?**

It collects available trading configuration details, such as base and quote currencies, tick size, minimum order size, and trading status.

**Which candlestick intervals are supported?**

The configured intervals are `1m`, `5m`, `15m`, `30m`, `1hr`, `6hr`, and `1day`, subject to availability.

**How fresh is the collected market data?**

Each run collects the information available at collection time. The `scraped_at` field records when a row was saved; it does not guarantee a particular exchange response latency.

**Why are some fields missing?**

The available fields depend on the collection mode and the data returned for a particular market or candle.

**Can I export the results to CSV or Excel?**

Yes. The completed dataset can be downloaded as JSON, CSV, or Excel.

### Disclaimer

This actor is an independent data-collection tool and is not affiliated with, endorsed by, sponsored by, or officially associated with Gemini or its owners. Market data is provided for informational and research purposes. Users are responsible for evaluating the suitability of the collected information for their intended use. Nothing in the dataset constitutes financial advice or a recommendation to buy or sell cryptocurrency.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects information from public pages. It does not log in and it does not bypass access controls.

For a longer explanation, see Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `symbols` (type: `array`):

Gemini pair symbols such as btcusd. Used by ticker, details, and candles. One symbol per line. The symbols mode ignores this list and reads the public catalog.

## `mode` (type: `string`):

What to collect: ticker (bid, ask, last), symbols (public pair catalog), details (pair rules), or candles (OHLC bars).

## `timeFrame` (type: `string`):

Candle interval for candles mode. Allowed values: 1m, 5m, 15m, 30m, 1hr, 6hr, 1day.

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

Maximum dataset rows to save this run, including error rows. Free cap is 1000.

## `requestDelaySecs` (type: `number`):

Seconds to wait between Gemini requests. The public API asks for about one request per second, so the floor is 1.

## `timeoutSecs` (type: `integer`):

Stop the run after this many seconds and keep rows already saved.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single Gemini response before retrying.

## `proxyConfiguration` (type: `object`):

Optional proxy for Gemini requests. Default is no proxy.

## Actor input object example

```json
{
  "symbols": [
    "btcusd"
  ],
  "mode": "ticker",
  "timeFrame": "1hr",
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with ticker, symbol, detail, and candle rows.

## `datasetItems` (type: `string`):

JSON items from the default dataset.

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

Table view of the default 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 = {
    "symbols": [
        "btcusd"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("real-estate-api/gemini-exchange-prices-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 = {
    "symbols": ["btcusd"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("real-estate-api/gemini-exchange-prices-scraper").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 '{
  "symbols": [
    "btcusd"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call real-estate-api/gemini-exchange-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,real-estate-api/gemini-exchange-prices-scraper"
        }
    }
}
```

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/t3pd4ea2rcYhk29ud/builds/4xoHDjK0u5Aa86ngq/openapi.json