home / skills / hummingbot / skills / find-arbitrage-opps

find-arbitrage-opps skill

/skills/find-arbitrage-opps

This skill identifies cross-exchange arbitrage opportunities by comparing fungible token prices and recommending profitable buy-sell spreads across connected

npx playbooks add skill hummingbot/skills --skill find-arbitrage-opps

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
3.8 KB
---
name: find-arbitrage-opps
description: Find arbitrage opportunities across exchanges by comparing prices for fungible token pairs like BTC/WBTC and USDT/USDC.
metadata:
  author: hummingbot
---

# find-arbitrage-opps

Find arbitrage opportunities across all Hummingbot-connected exchanges by comparing prices for a trading pair, accounting for fungible tokens (e.g., BTC = WBTC, USDT = USDC).

## Prerequisites

Hummingbot API must be running with exchange connectors configured:

```bash
bash <(curl -s https://raw.githubusercontent.com/hummingbot/skills/main/skills/lp-agent/scripts/check_prerequisites.sh)
```

## DEX Support

By default the script queries CEX connectors via the Hummingbot API. Add `--dex` to also fetch prices from:

| DEX | Chain | Default Network |
|-----|-------|-----------------|
| **Jupiter** | Solana | `mainnet-beta` |
| **Uniswap** | Ethereum | `mainnet` |
| **PancakeSwap** | Ethereum (BSC) | `bsc` |

DEX prices are fetched directly via the Hummingbot Gateway. Make sure Gateway is running on `http://localhost:15888` (or set `GATEWAY_URL`).

> ⚠️ **BTC markets** are only available to Australian residents on some exchanges. A warning is printed automatically when BTC/WBTC/cbBTC is included in the search.

## Workflow

### Step 1: Define Token Mappings

User specifies the base and quote tokens, including fungible equivalents:

- **Base tokens**: BTC, WBTC, cbBTC (all represent Bitcoin)
- **Quote tokens**: USDT, USDC, USD (all represent USD)

### Step 2: Find Arbitrage Opportunities

```bash
# Basic - CEX only
python scripts/find_arb_opps.py --base BTC --quote USDT

# Include fungible tokens
python scripts/find_arb_opps.py --base BTC,WBTC --quote USDT,USDC

# Include DEX prices (Jupiter + Uniswap via Gateway)
python scripts/find_arb_opps.py --base SOL --quote USDC --dex
python scripts/find_arb_opps.py --base ETH,WETH --quote USDT,USDC --dex

# Minimum spread filter
python scripts/find_arb_opps.py --base SOL --quote USDC --dex --min-spread 0.1

# Filter to specific CEX connectors
python scripts/find_arb_opps.py --base BTC --quote USDT --connectors binance,kraken,coinbase
```

### Step 3: Analyze Results

The script outputs:
- Prices from each CEX and DEX source
- Best bid/ask across all sources
- Arbitrage spread (buy low, sell high)
- Recommended pairs for arbitrage

## Script Options

```bash
python scripts/find_arb_opps.py --help
```

| Option | Description |
|--------|-------------|
| `--base` | Base token(s), comma-separated (e.g., BTC,WBTC) |
| `--quote` | Quote token(s), comma-separated (e.g., USDT,USDC) |
| `--connectors` | Filter to specific CEX connectors (optional) |
| `--dex` | Include DEX prices via Gateway (Jupiter + Uniswap) |
| `--min-spread` | Minimum spread % to show (default: 0.0) |
| `--json` | Output as JSON |

## Output Example

```
============================================================
  SOL / USDC Arbitrage Scanner
  DEX: Jupiter (Solana mainnet-beta), Uniswap (Ethereum mainnet)
============================================================

  Lowest:  binance                   $132.4500
  Highest: jupiter (DEX)             $132.8900
  Spread:  0.332% ($0.4400)
  Sources: 5 prices from 5 sources

  Top Arbitrage Opportunities:
  --------------------------------------------------------
  1. Buy  binance                   @ $132.4500
     Sell jupiter (DEX)             @ $132.8900
     Profit: 0.332% ($0.4400)
```

## Environment Variables

```bash
export HUMMINGBOT_API_URL=http://localhost:8000
export API_USER=admin
export API_PASS=admin
export GATEWAY_URL=http://localhost:15888   # for DEX prices
```

Scripts check for `.env` in: `./hummingbot-api/.env` → `~/.hummingbot/.env` → `.env`

## Requirements

- Hummingbot API running (for CEX prices)
- Gateway running (for DEX prices with `--dex` flag)
- Exchange connectors configured with API keys

Overview

This skill finds cross-exchange arbitrage opportunities for fungible token pairs by comparing live prices across all Hummingbot-connected exchanges. It normalizes equivalent tokens (for example BTC/WBTC or USDT/USDC) so you can spot buy-low / sell-high paths across connectors. The skill outputs exchange prices, best bid/ask, spread percentages, and recommended trading pairs.

How this skill works

The skill queries the Hummingbot API for market prices across configured exchange connectors and normalizes base and quote tokens using user-specified mappings. It computes best bids and asks, calculates percentage and absolute spreads, applies optional filters (connectors, minimum spread), and can emit results in human-readable text or JSON. Results indicate where to buy, where to sell, and the potential spread after simple aggregation.

When to use it

  • When you need to discover simple cross-exchange arbitrage opportunities between fungible token representations (e.g., BTC vs WBTC).
  • When evaluating whether price differences across exchanges are meaningful before funding a strategy.
  • When you want a quick overview of best bid/ask across many connectors without manual aggregation.
  • When screening markets to feed into an automated trading strategy or execution system.
  • When validating exchange connectivity and price feeds from Hummingbot API.

Best practices

  • Specify all fungible equivalents for base and quote tokens to ensure complete coverage (e.g., BTC,WBTC,cbBTC and USDT,USDC,USD).
  • Filter connectors if you only trade on specific venues to avoid irrelevant opportunities and reduce noise.
  • Set a realistic --min-spread to ignore micro spreads that won’t cover fees, slippage, and transfer costs.
  • Verify API connectivity and keys are configured for each exchange before relying on results.
  • Treat output as an informational signal; perform additional checks for liquidity, fees, and transfer time before executing trades.

Example use cases

  • Scan for BTC arbitrage across centralized exchanges, including WBTC mappings to catch wrapped-token listings.
  • Compare USD-stablecoin quote variants (USDT vs USDC vs USD) to find stablecoin-based arbitrage.
  • Limit scans to a subset of connectors (e.g., binance,kraken,coinbase) to focus on high-liquidity venues.
  • Automate periodic scans and output JSON to feed a downstream bot that evaluates execution viability.
  • Pre-check markets for a manual arbitrage execution, reviewing price, spread, and recommended buy/sell pairs.

FAQ

Do I need Hummingbot running?

Yes — the skill queries the Hummingbot API and requires exchange connectors configured and reachable.

How do I handle fees and slippage?

This tool reports raw spreads. You should subtract estimated fees and account for expected slippage before deciding to execute.