# ArbTide API

The ArbTide API returns normalized funding rates, funding history, live prices, net-of-fee arbitrage routes and cash-and-carry trades for 35 exchanges as JSON, collected directly from exchange APIs. Every call needs an API key and is counted in credits: 100 a day with a free key to try it, and 5,000,000 a month on Pro for your own tools and bots.

- Base URL: https://arbtide.com/api/v1
- OpenAPI 3.1 spec: https://arbtide.com/api/v1/openapi.json
- Get an API key: https://arbtide.com/account/api

## Quick start

```bash
curl -H "x-api-key: $ARBTIDE_KEY" https://arbtide.com/api/v1/funding-rates/btc
```

```
HTTP/2 200
x-credits-cost: 1
x-credits-remaining: 99
x-credits-reset: 2026-11-19T00:00:00.000Z

{
  "data": {
    "coin": "BTC",
    "averageApr": 0.041570354826308845,
    "spreadApr": 0.358503,
    "long": { "exchange": "deepcoin", "rate": -0.0001624, "intervalHours": 8, "apr": -0.17782799999999999 },
    "short": { "exchange": "xt", "rate": 0.000165, "intervalHours": 8, "apr": 0.180675 },
    "rates": [
      { "exchange": "xt", "symbol": "BTC/USDT:USDT", "rate": 0.000165, "intervalHours": 8, "apr": 0.180675 },
      { "exchange": "extended", "symbol": "BTC/USDC:USDC", "rate": 0.000013, "intervalHours": 1, "apr": 0.11388, "markPrice": 64656.27777825 }
    ]
  },
  "meta": { "updatedAt": "2026-11-18T07:22:10.514Z" }
}
```

## Examples

Copy one, set ARBTIDE_KEY and run it. Every reply tells you in its headers how many credits the call cost.

### Python: the best price routes after fees

```python
import os
import requests

API = "https://arbtide.com/api/v1"
headers = {"x-api-key": os.environ["ARBTIDE_KEY"]}

# Price routes with a positive spread after fees, widest first (5 credits)
reply = requests.get(f"{API}/arbitrage", params={"type": "perp", "limit": 10}, headers=headers)
for route in reply.json()["data"]:
    print(route["coin"], route["buy"]["exchange"], "->", route["sell"]["exchange"], f'{route["netSpread"]:.2%} net')

print("credits left:", reply.headers["x-credits-remaining"])
```

### JavaScript: the widest funding gaps

```javascript
// Node 18+ or any browser-less runtime with fetch
const reply = await fetch("https://arbtide.com/api/v1/funding-rates?limit=10", {
  headers: { "x-api-key": process.env.ARBTIDE_KEY },
})
const { data } = await reply.json()

for (const coin of data) {
  console.log(coin.coin, `${(coin.spreadApr * 100).toFixed(1)}% APR`, "long", coin.long.exchange, "short", coin.short.exchange)
}
console.log("credits left:", reply.headers.get("x-credits-remaining"))
```

### Python: a polling alert to Discord

```python
import os, time, requests

API = "https://arbtide.com/api/v1"
HEADERS = {"x-api-key": os.environ["ARBTIDE_KEY"]}
DISCORD = os.environ["DISCORD_WEBHOOK_URL"]

def get(path, **params):
    while True:
        reply = requests.get(f"{API}{path}", params=params, headers=HEADERS)
        if reply.status_code == 429 and reply.json()["error"]["code"] == "rate_limited":
            time.sleep(int(reply.headers.get("Retry-After", 1)))  # the speed limit refills every second
            continue
        reply.raise_for_status()
        return reply.json()["data"]

seen = set()
while True:
    # A list costs 5 credits: every 15 minutes is 480 a day, so run this on Pro. Free has 100 a day.
    for route in get("/arbitrage", type="perp", minNetSpread=0.005, limit=5):
        key = (route["coin"], route["buy"]["exchange"], route["sell"]["exchange"])
        if key not in seen:
            seen.add(key)
            requests.post(DISCORD, json={"content": f'{route["coin"]}: {route["netSpread"]:.2%} net, buy {key[1]}, sell {key[2]}'})
    time.sleep(15 * 60)
```

### Google Sheets: funding rates for one coin (Apps Script)

```javascript
// Google Sheets: Extensions > Apps Script. Save the key under Project Settings > Script properties as ARBTIDE_KEY.
// In a cell: =ARBTIDE_FUNDING("BTC")
function ARBTIDE_FUNDING(coin) {
  const key = PropertiesService.getScriptProperties().getProperty("ARBTIDE_KEY")
  const reply = UrlFetchApp.fetch("https://arbtide.com/api/v1/funding-rates/" + String(coin).toLowerCase(), { headers: { "x-api-key": key } })
  return JSON.parse(reply.getContentText()).data.rates.map((rate) => [rate.exchange, rate.rate, rate.apr])
}
```

## Plans

| Limit | Free | Pro |
| --- | --- | --- |
| Credits | 100 a day | 5,000,000 a month |
| Speed limit | 1 a second | 50 a second |
| API keys | 1 | 10 |
| Key lifetime | Up to 30 days | 30 days to never |
| Keys limited to your IP addresses | — | Included |
| Access to your alerts and watchlist | — | Included |
| Funding history per call | 7 days | 90 days |

## Credits

Every call costs credits by how much it returns: one coin or one exchange costs 1, a full list 5, and funding history 1 for each day it returns. Both your quota and your speed limit are counted in credits, so a heavy call simply uses more of them.

| Method | Path | Description | Credits |
| --- | --- | --- | --- |
| GET | /api/v1/exchanges | List exchanges with market counts and volume | 1 |
| GET | /api/v1/exchanges/{exchange}/funding-rates | Every linear perpetual funding rate on one exchange | 5 |
| GET | /api/v1/funding-rates | Funding summary for every coin listed on at least two exchanges | 5 |
| GET | /api/v1/funding-rates/{coin} | Funding rates for one coin on every exchange | 1 |
| GET | /api/v1/funding-rates/{coin}/history | Hourly funding history for one coin. One credit per day asked for; Free up to 7 days, Pro up to 90 | 1 per day |
| GET | /api/v1/arbitrage | Price arbitrage routes with a positive net spread | 5 |
| GET | /api/v1/arbitrage/{coin} | Best spot and perpetual route for one coin, including unprofitable ones | 1 |
| GET | /api/v1/strategies/cash-and-carry | Cash-and-carry trades: buy spot, short the perpetual, earn funding | 5 |
| GET | /api/v1/prices/{coin} | Live bid and ask for one coin on every exchange and market type | 1 |
| GET | /api/v1/status | Data collection status of every exchange and stream | 1 |

## API keys

- Create keys on the API tab of your account. A key is shown once, when you create it; send it as `x-api-key: arb_…` or `Authorization: Bearer arb_…`.
- Every key stops working after the lifetime you pick: Free keys last up to 30 days, Pro keys 30, 90 or 365 days or never. The owner is emailed a week before.
- Replacing a key issues a new one with the same settings; the old one keeps working for 24 hours.
- On Pro a key can be limited to up to 20 IP addresses or IPv4 ranges, and can be allowed to read your account (alerts, alert history, watchlist).

## Limits and headers

Free credits start again at each UTC midnight, Pro credits at the start of each UTC month. The speed limit refills every second and lets you spend up to 5 seconds' worth at once. Every reply carries these headers:

- `X-Credits-Cost`: Credits this call used.
- `X-Credits-Remaining`: Credits left this period.
- `X-Credits-Limit`: Your quota for the period.
- `X-Credits-Reset`: When the quota starts again (UTC).
- `X-RateLimit-Remaining`: Credits you can spend right now before the speed limit applies.
- `Retry-After`: Seconds to wait, sent when the speed limit refused a call.

## Errors

| Status | Code | Meaning |
| --- | --- | --- |
| 400 | `invalid_request` | A parameter is missing or not valid; the message says which. |
| 401 | `api_key_required` | No API key was sent. Create a free one on your account’s API tab. |
| 401 | `invalid_api_key` | The key is wrong or was revoked. |
| 401 | `key_expired` | The key has stopped working. Replace it or create a new one. |
| 403 | `ip_not_allowed` | The key is limited to other IP addresses. |
| 403 | `insufficient_scope` | The key is not allowed to read this, such as your account. |
| 403 | `upgrade_required` | This needs a higher plan. |
| 404 | `not_found` | No such coin, exchange or route. |
| 429 | `rate_limited` | Too fast. Wait the seconds in Retry-After. |
| 429 | `quota_exceeded` | This period's credits are used up. They come back at X-Credits-Reset. |

## Frequently asked questions

### Do I need an API key?

Yes. Every call needs a key, and a free one takes a minute: create it on the API tab of your account, no card needed. A key is shown once, and you can replace or revoke it at any time.

### What does the free key include?

100 credits a day at 1 credit a second, one market-data key that lasts up to 30 days, and 7 days of funding history per call. It is meant for trying the API. Pro raises it to 5,000,000 credits a month, 10 keys, IP limits and 90 days of history.

### How are credits counted?

By how much a call returns: one coin or one exchange costs 1 credit, a full list 5, and funding history 1 credit for each day. Your quota and your speed limit are both counted in credits, and every reply tells you what it cost and what is left.

### Where does the data come from?

Directly from the public APIs of 35 exchanges, collected on our own servers and normalized to comparable units, with fees taken off. ArbTide does not resell data from aggregators.

### Can I build a product on the API?

You may use the data for personal and internal tools on any plan. You may not resell the raw data, work around the limits or scrape in a way that harms the service. The Terms have the details.

Responses are `{ "data": …, "meta": … }`; errors are `{ "error": { "code", "message" } }`. Rates, spreads and APRs are fractions: 0.0001 = 0.01%.
