# Intro
Velo API keys are available at $199/mo.
Subscriptions are payable monthly (3 month history) or yearly (full data history).
**Please see the** [**subscription**](https://velo.xyz/subscription) **page in the web app to get a key or request a trial.**
***
All data is available in >=1 minute resolution. The endpoints [/futures](https://api.velo.xyz/api/v1/futures), [/options](https://api.velo.xyz/api/v1/options), and [/spot](https://api.velo.xyz/api/v1/spot) can be used without authentication to view available products and their histories. See the Columns page for available data types.
```python
from velodata import lib as velo
client = velo.client('api_key')
ten_minutes_ms = 1000 * 60 * 10
params = {
'type': 'futures',
'columns': ['close_price', 'funding_rate'],
'exchanges': ['binance-futures', 'bybit'],
'products': ['BTCUSDT'],
'begin': client.timestamp() - ten_minutes_ms,
'end': client.timestamp(),
'resolution': '1m'
}
print(client.get_rows(params))
```
The API can be accessed via HTTP/Curl, our Python library, or our NodeJS library. Access also includes the ability to download CSV data from applicable charts via the webapp.
# News API
News API access is available with data API keys, or separately from $129/mo.
Please see the [subscription](https://velo.xyz/subscription) page in the webapp to get a key.
News objects contain the following fields:
```json
{
id: 55, // unique identifier
time: 1704085200000, // timestamp the news was published
effectiveTime: 1704085200000, // timestamp the news happened
headline: "Hello world",
source: "Velo",
priority: 2, // 1 = top priority only, 2 = everything else
coins: ['BTC'], // list of relevant coins
summary: "# Hello world", // may include markdown
link: "https://velo.xyz" // source link
}
```
The WebSocket may also send edit events which will have all fields above plus `edit: true` , or delete events which will have only the following `{id: id, deleted: true}`.
***
### Python
Quick Start
```python
import asyncio
from velodata import lib as velo
# new velo client
client = velo.client('api_key')
# get past stories
print(client.news.get_news())
# stream new stories
async def stream():
async for message in client.news.stream_news():
if(message in ('connected', 'heartbeat', 'closed')):
print(message)
else:
print(json.loads(message))
asyncio.run(stream())
```
Get news
`news.get_news(begin)`
* begin (optional, defaults to 0): millisecond timestamp to only fetch news after
Returns list of news objects (dicts)
Stream news
`news.stream_news()`
Returns generator, generator returns 'connected', 'heartbeat', 'closed', or news object (dict)
Close stream
`news.close_stream()`
Closes open websocket and exits generator
***
### NodeJS
Quick Start
```javascript
const velo = require('velo-node')
async function doWork() {
// get past stories
const stories = await client.news.stories()
console.log(stories)
// stream new stories
const socket = client.news.stream()
socket.on('open', () => console.log('connected'))
socket.on('close', () => console.log('closed'))
socket.on('error', (err) => {
console.log('error', err)
socket.close()
})
socket.on('message', (data) => {
const json = JSON.parse(data.toString())
if (json.heartbeat) {
console.log('heartbeat')
return
}
console.log(json)
})
}
const client = new velo.Client('api_key')
doWork()
```
Get news
`news.stories({begin})`
* begin (optional, defaults to 0): millisecond timestamp to only fetch news after
Returns list of news Objects
Stream news
`news.stream()`
Returns [WebSocket](https://github.com/websockets/ws/blob/HEAD/doc/ws.md#class-websocket), WebSocket sends 'connected', 'heartbeat', 'closed', or news Object
***
### HTTP
Quick Start
`$ curl -v --user "api:api_key" "https://api.velo.xyz/api/n/news?begin=0"`
Get news
`/news`
* begin (optional, defaults to 0): millisecond timestamp to only fetch news after
Returns JSON
# Python
pip install velodata
[GitHub](https://github.com/velodataorg/velo-python), [PyPi](https://pypi.org/project/velodata/)
### Examples
Quick Start
```python
from velodata import lib as velo
# new velo client
client = velo.client('api_key')
# get futures and pick one
future = client.get_futures()[0]
# get futures columns and pick two
columns = client.get_futures_columns()[:2]
# last 10 minutes in 1 minute resolution
params = {
'type': 'futures',
'columns': columns,
'exchanges': [future['exchange']],
'products': [future['product']],
'begin': client.timestamp() - 1000 * 60 * 11,
'end': client.timestamp(),
'resolution': '1m'
}
# returns dataframe
print(client.get_rows(params))
```
Aggregated Spot CVD
```python
from velodata import lib as velo
day_in_ms = 1000 * 60 * 60 * 24
# new velo client
client = velo.client('api_key')
# from one day ago in 10 minute resolution
params = {
'type': 'spot',
'columns': ['buy_dollar_volume', 'sell_dollar_volume'],
'exchanges': ['coinbase', 'binance', 'bybit-spot'],
'products': ['ETHUSDT', 'ETH-USD'],
'begin': client.timestamp() - day_in_ms,
'end': client.timestamp(),
'resolution': '10m'
}
# returns dataframe
df = client.get_rows(params)
# aggregate all exchanges
df = df.groupby(df['time']).sum(numeric_only=True)
# compute volume delta
df['delta'] = df['buy_dollar_volume'] - df['sell_dollar_volume']
# cumulative
print(df['delta'].cumsum())
```
OI-Weighted Funding Rate
```python
from velodata import lib as velo
hour_in_ms = 1000 * 60 * 60
# new velo client
client = velo.client('api_key')
# from one hour ago in 1 minute resolution
params = {
'type': 'futures',
'columns': ['funding_rate', 'coin_open_interest_close'],
'exchanges': ['binance-futures', 'bybit', 'okex-swap'],
'coins': ['SOL'],
'begin': client.timestamp() - hour_in_ms,
'end': client.timestamp(),
'resolution': '1m'
}
# returns dataframe
df = client.get_rows(params)
# oi-weighted funding = SUM(funding*OI) / SUM(OI)
df['funding_rate'] = df['funding_rate'] * df['coin_open_interest_close']
df = df.groupby(df['time']).sum(numeric_only=True)
df['funding_rate'] = df['funding_rate'] / df['coin_open_interest_close']
print(df['funding_rate'])
```
Spot-Vol Correlation
```python
from velodata import lib as velo
day_in_ms = 1000 * 60 * 60 * 24
# new velo client
client = velo.client('api_key')
# from 5 days ago in 1 hour resolution
params = {
'type': 'options',
'columns': ['dvol_close', 'index_price'],
'exchanges': ['deribit'],
'products': ['BTC'],
'begin': client.timestamp() - day_in_ms * 5,
'end': client.timestamp(),
'resolution': '1h'
}
# returns dataframe
df = client.get_rows(params)
# simple rolling 24 hour correlation
print(
df['dvol_close'].pct_change().rolling(24).corr(df['index_price'].pct_change())
)
```
Futures Basis
*Special case: \`3m\_basis\_ann\` is available for BTC and ETH. To request this data, do not specify products, exchanges, or any additional columns*
```python
from velodata import lib as velo
day_in_ms = 1000 * 60 * 60 * 24
# new velo client
client = velo.client('api_key')
# from 5 days ago in 1 hour resolution
params = {
'type': 'futures',
'columns': ['3m_basis_ann'],
'coins': ['BTC', 'ETH'],
'begin': client.timestamp() - day_in_ms * 5,
'end': client.timestamp(),
'resolution': '1h'
}
# returns dataframe
print(client.get_rows(params))
```
Large Request
Both `get_rows` and `stream_rows` handle batching of large requests automatically, but if you wish to receive batch responses individually rather than in one final DataFrame you should use `stream_rows`.
```python
from velodata import lib as velo
day_in_ms = 1000 * 60 * 60 * 24
# new velo client
client = velo.client('api_key')
# from 5 days ago in 1 minute resolution
# 2 columns * 4 products * 1 exchange * 7200 rows = 57600 values
params = {
'type': 'futures',
'columns': ['open_price', 'close_price'],
'exchanges': ['binance-futures'],
'products': ['LTCUSDT', 'ETCUSDT', 'BCHUSDT', 'SOLUSDT'],
'begin': client.timestamp() - day_in_ms * 5,
'end': client.timestamp(),
'resolution': '1m'
}
# creates 3 batches (57600 values / 22500 limit)
batches = client.batch_rows(params)
# prints each batch as it finishes
for df in client.stream_rows(batches):
print(df)
```
Orderbook Data
The `depth` function returns orderbook depth data in snapshots with the specified resolution over the specified time period.
```python
from velodata import lib as velo
day_in_ms = 1000 * 60 * 60 * 24
# new velo client
client = velo.client('api_key')
# pick a supported future
futures = client.get_futures()
futures_with_orderbook_data = [f for f in futures if f['depth']]
future = futures_with_orderbook_data[0]
# last 24 hours in 5 minute resolution
params = {
'exchange': future['exchange'],
'product': future['product'],
'begin': client.timestamp() - day_in_ms,
'end': client.timestamp(),
'resolution': '5m'
}
# prints orderbook at each timestamp as it finishes
for df in client.depth(params):
print(df)
```
***
### Helper Methods
* Key status: `get_status()`
* Supported futures: `get_futures(delisted=False)`
* Supported options: `get_options()`
* Supported spot pairs: `get_spot(delisted=False)`
* Supported futures columns: `get_futures_columns()`
* Supported options columns: `get_options_columns()`
* Supported spot columns: `get_spot_columns()`
* Millisecond timestamp: `timestamp()`
***
### **Data Methods**
Get rows
`get_rows(params)`
* type: 'futures', 'options', or 'spot'
* exchanges, products, coins, columns: lists
* begin, end: millisecond timestamps
* resolution: minutes (integer) or resolution (string)
Returns DataFrame
*If both \`coins\` and \`products\` are specified, only \`products\` will be used*
Batch rows
`batch_rows(params)`
* type: 'futures', 'options', or 'spot'
* exchanges, products, coins, columns: lists
* begin, end: millisecond timestamps
* resolution: minutes (integer)
Returns list for use in `stream_rows`
*If both \`coins\` and \`products\` are specified, only \`products\` will be used*
Stream rows
`stream_rows(batches)`
* batches: list returned from `batch_rows`
Yields DataFrame
Get options term structure
`get_term_structure(coins)`
* coins: list
Returns DataFrame
*Latest values only*
Get market caps
`get_market_caps(coins)`
* coins: list
Returns DataFrame
*Latest values only*
Get orderbook data
`depth(params)`
* exchange, product, coin: string
* begin, end: millisecond timestamps
* resolution: minutes (integer) or resolution (string)
Yields object with `timestamp`, `midprice`, and `price:value` pairs.
*Use 'coin' only for aggregated orderbook data. Use 'product' and 'exchange' for a specific product.*
# NodeJS
npm install velo-node
[GitHub](https://github.com/velodataorg/velo-node/tree/main), [npm](https://www.npmjs.com/package/velo-node)
### Examples
Quick Start
```javascript
const velo = require('velo-node')
async function doWork() {
const futures = await client.futures()
const future = futures[0]
const columns = client.futuresColumns()
const twoColumns = columns.slice(0, 2)
const params = {
type: 'futures',
columns: twoColumns,
exchanges: [future.exchange],
products: [future.product],
begin: Date.now() - 1000 * 60 * 11, // 10 minutes
end: Date.now(),
resolution: '1m' // 1 minute
}
const rows = client.rows(params)
for await (const row of rows) {
console.log(row)
}
}
const client = new velo.Client('api_key')
doWork()
```
Orderbook Data
```javascript
const velo = require('velo-node')
async function doWork() {
const futures = await client.futures()
const future = futures.filter((f) => f.depth)[0]
const dayInMs = 1000 * 60 * 60 * 24
const params = {
exchange: future.exchange,
product: future.product,
begin: Date.now() - dayInMs,
end: Date.now(),
resolution: '5m'
}
const iter = client.depth(params)
for await (const depth of iter) {
console.log(depth)
}
}
const client = new velo.Client('api_key')
doWork()
```
***
### Helper Methods
* Key status: `status()`
* Supported futures: `futures(delisted=False)`
* Supported options: `options()`
* Supported spot pairs: `spot(delisted=False)`
* Supported futures columns: `futuresColumns()`
* Supported options columns: `optionsColumns()`
* Supported spot columns: `spotColumns()`
***
### Data Methods
Get rows
`rows(params)`
* type: 'futures', 'options', or 'spot'
* exchanges, products, coins, columns: arrays
* begin, end: millisecond timestamps
* resolution: minutes (integer) or resolution (string)
Asynchronously returns individual rows (Objects)
*If both \`coins\` and \`products\` are specified, only \`products\` will be used*
Get options term structure
`termStructure(params)`
* coins: array
Returns Object
*Latest values only*
Get market caps
`marketCaps(params)`
* coins: array
Returns Object
*Latest values only*
Get orderbook data
`depth(params)`
* exchange, product, coin: string
* begin, end: millisecond timestamps
* resolution: minutes (integer) or resolution (string)
Asynchronously returns Object with `time`, `mid`, and `price:value` pairs.
*Use 'coin' only for aggregated orderbook data. Use 'product' and 'exchange' for a specific product.*
# HTTP
HTTP endpoints
Base: `https://api.velo.xyz/api/v1`
### **Examples**
**Quick Start**
`$ curl -v --user "api:api_key" "https://api.velo.xyz/api/v1/caps?coins=BTC,ETH"`
***
### **Helper Methods**
* Key status: `/status`
* Supported futures: [`/futures`](https://api.velo.xyz/api/v1/futures)
* Supported options: [`/options`](https://api.velo.xyz/api/v1/options)
* Supported spot pairs: [`/spot`](https://api.velo.xyz/api/v1/spot)
***
### Data Methods
Get rows
`/rows`
* type: 'futures', 'options', or 'spot'
* exchanges, products, coins, columns: comma separated for multiple
* begin, end: millisecond timestamp
* resolution: minutes or resolution string
Returns text in CSV format
*HTTP requests are limited to returning 22500 values per request. See an example implementation of request batching* [*here*](https://github.com/velodataorg/velo-node/blob/34489ca79211e4bae171c5da0f0b9beee3b2f214/lib/client.js#L72)
*If both \`coins\` and \`products\` are specified, only \`products\` will be used*
Get options term structure
`/terms`
* coins: comma separated for multiple
Returns text in CSV format
*Latest values only*
Get market caps
`/caps`
* coins: comma separated for multiple
Returns text in CSV format
*Latest values only*
# Columns
Supported columns for rows functions
Also viewable from helper methods in the [Python](/api/python) and [NodeJS](/api/nodejs) libraries.
Futures
```
'open_price',
'high_price',
'low_price',
'close_price',
'coin_volume',
'dollar_volume',
'buy_trades',
'sell_trades',
'total_trades',
'buy_coin_volume',
'sell_coin_volume',
'buy_dollar_volume',
'sell_dollar_volume',
'coin_open_interest_high',
'coin_open_interest_low',
'coin_open_interest_close',
'dollar_open_interest_high',
'dollar_open_interest_low',
'dollar_open_interest_close',
'funding_rate',
'funding_rate_avg',
'premium',
'buy_liquidations',
'sell_liquidations',
'buy_liquidations_coin_volume',
'sell_liquidations_coin_volume',
'liquidations_coin_volume',
'buy_liquidations_dollar_volume',
'sell_liquidations_dollar_volume',
'liquidations_dollar_volume'
```
*All funding rates are normalized to per 8 hours*
*Special case: \`3m\_basis\_ann\` is available for BTC and ETH. To request this data, do not specify products, exchanges, or any additional columns*
Options
```
'iv_1w',
'iv_1m',
'iv_3m',
'iv_6m',
'skew_1w',
'skew_1m',
'skew_3m',
'skew_6m',
'vega_coins',
'vega_dollars',
'call_delta_coins',
'call_delta_dollars',
'put_delta_coins',
'put_delta_dollars',
'gamma_coins',
'gamma_dollars',
'call_volume',
'call_premium',
'call_notional',
'put_volume',
'put_premium',
'put_notional',
'dollar_volume',
'dvol_open',
'dvol_high',
'dvol_low',
'dvol_close',
'index_price'
```
*See how we calculate options values* [*here*](/web-app/options)
Spot
```
'open_price',
'high_price',
'low_price',
'close_price',
'coin_volume',
'dollar_volume',
'buy_trades',
'sell_trades',
'total_trades',
'buy_coin_volume',
'sell_coin_volume',
'buy_dollar_volume',
'sell_dollar_volume',
```
# Intro
This section provides information pertaining particularly to Velo's webapp. For a more general guide to crypto markets, we recommend [Binance Academy](https://academy.binance.com/en/articles?page=1\&tags=trading) and [Deribit Insights](https://insights.deribit.com/options-course/).
Helpful video tutorials showing some of our webapp features are available [here](https://www.youtube.com/watch?v=WsqB-FI2gEs) and [here](https://www.youtube.com/watch?v=UBmkDrakNeQ).
Support:
# Chart
Velo uses [TradingView's](https://www.tradingview.com/) library to support seamless switching of coins and timeframes. Data updates live up to 10x per second and users may save up to 4 layouts that will persist across browser sessions. The chart can be taken into full screen, changed to line style, and broken into up to 16 panes.
*The charting technology is provided by TradingView, a platform for traders and investors. It offers advanced charting tools where people driven by markets can track major upcoming events in the* [*Economic calendar,*](https://www.tradingview.com/economic-calendar/) *chat, chart, and prepare for trades.*
## Indicators
Indicators may have additional functionality unlocked (including the ability to filter aggregated data by exchange) by mousing over their names and clicking the settings icon.
Indicators not prefixed by "\" are preset TradingView indicators and their definitions may be seen [here](https://www.tradingview.com/support/categories/indicators/).
Open Interest
Open interest is viewable in dollar or coin terms, and in the form of candlesticks or bar-to-bar changes (absolute and percentage).
Liquidations
Liquidations are viewable in dollar or coin terms, and in the form of long and short, total count, long only, or short only.
Users may also enable a hitmarker sound to play on each liquidation.
Funding
Funding is viewable standardized to per 1 hour, 8 hours, 24 hours, or 1 year, and in the form of rate (%), total coin spend, or total dollar spend.
Funding spends are calculated as funding rate times open interest.
The view input of this indicator controls whether the average or the last value is returned for each individual bar.
*By default Velo shows funding rates as they update, rather than as they were at their last payment interval. This may sometimes be referred to elsewhere as a "predicted funding rate."*
Premium
Premium is mark price vs. index price as reported by each exchange. It is viewable in terms of dollars or percent.
The view input of this indicator controls whether the average or the last value is returned for each individual bar. The moving average input controls if and how an average is returned for a period of multiple bars.
*See how Binance defines mark prices and index prices* [*here*](https://www.binance.com/en/support/faq/what-are-mark-price-and-price-index-in-usd%E2%93%A2-margined-futures-360033525071)*. Most exchanges follow similar definitions.*
Volume
Volume is viewable in dollar or coin terms, as well as in the form of volume delta or cumulative volume delta.
The volume delta of a period is the value of market buys minus the value of market sells during that period. Cumulative volume delta is the cumulative sum of the volume deltas of multiple periods.
Tape
Tape data is viewable in total trade count or tape speed (trades per minute) terms, as well as in the form of trade delta or cumulative trade delta.
The trade delta of a period is the number market buys minus the number of market sells during that period. Cumulative trade delta is the cumulative sum of the trade deltas of multiple periods.
Moving Average
In addition to two standard [moving averages](https://www.tradingview.com/support/solutions/43000502589-moving-averages/), volume weighted average price (VWAP) and open interest weighted average price (OIWAP) are viewable.
* The VWAP is the total dollar value of all trades in a period divided by the total number of contracts traded in a period.
* The open interest weighted average price (OIWAP) is the total dollar value of all open positions in a period divided by the total coin value of all open contracts in a period.
*Because of the less volatile nature of open interest, an OIWAP may at times appear similar to a standard moving average. This indicator may be reworked in the future.*
Returns
Returns (bar to bar close) are viewable in absolute or percentage terms and over one or multiple periods.
Realized Vol
Realized volatility is the annualized standard deviation of percent returns over a given period.
Total Return
Total return is the estimated value of a long position held in a perpetual future after funding rate payments are considered. Payments are not assumed to be compounded into the position and this value may vary slightly from true actualized returns.
Coinbase Premium
The Coinbase premium is the closing price for the selected symbol vs. the closing price of the matching Coinbase -USD pair, when one exists.
# Table
The table is sortable and will auto sort on new data. The data updates live between twice per second and once per minute where applicable.
Clicking a coin in the table will select its Binance USDT perpetual on the chart by default, or its Bybit USDT perpetual if applicable.
Users can favorite and unfavorite coins in the table, filter the display by coins and columns, and make watchlists. Watchlists can also be used on the [Market](/web-app/market) page. These configurations are saved across browser sessions and devices.
## Columns
Price
The last traded price of the coin's Binance USDT perpetual.
Chg
The 24 hour, 1 hour, 10 minute, or 7 day price change of the coin in percentage terms. The column with no duration specified shows change since daily open (UTC midnight).
Price/7d High or Low
The coin's last traded price vs. its highest or lowest traded price over the last 7 days.
Volume
The total dollar value of trades on the coin in the last 24 hours, 1 hour, or 10 minutes across all supported exchanges.
Volume Delta
The total volume delta (dollar value of market buys minus market sells) of the coin in the last 24 hours, 1 hour, or 10 minutes across all supported exchanges.
Open Interest
The coin's open interest in dollars across all supported exchanges.
OI Chg
The percent change between a coin's total dollar value open interest now and 24 hours ago.
Funding
24h Funding: The open-interest weighted 24 hour average funding rate of the coin across all supported exchanges.
24h Funding (APR): The above standardized per annum.
Funding: The most recent open-interest weighted funding rate of the coin across all supported exchanges.
24h Liquidations
The total number of liquidations on the coin in the last 24 hours across all supported exchanges.
Trades
The total number of trades on the coin in the last 24 hours, 1 hour, or 10 minutes across all supported exchanges.
Mkt Cap, FDV, and Float
The circulating market cap or fully diluted market cap of a coin. Calculated by supply \* price. Viewable also as Open Interest / circulating market cap, Open Interest / FDV, 24h Volume / circulating market cap, 24h Volume / FDV, or as Float (circulating divided by FDV).
24h Perp / Spot Volume Ratio
The ratio of 24 hour Binance USDT perpetual volume to 24 hour Binance spot USDT volume for the coin. Returns 0 if no spot pair is available.
# Futures
24h Volume
The total dollar value of trades on the coin in the last 24 hours, broken down into supported exchanges.
Open Interest Snapshot
The coin's open interest in dollars broken down into supported exchanges.
Funding
The coin's historical funding rate, per 8 hours or per annum and broken down into supported exchanges.
Open Interest
The coin's historical open interest in dollars broken down into supported exchanges.
Price
The last traded price of the coin's Binance USDT perpetual.
Basis
The annualized basis of the coin's rolling dated future expiring closest to three months in the future, broken down by exchange.
*BTC and ETH coin-margined futures only.*
Liquidations
The coin's historical liquidations in dollars broken down into supported exchanges. Short liquidations are shown above the x-axis and long liquidations are shown below.
Volume
The coin's historical dollar volume by period, broken down into supported exchanges.
CVD
The coin's cumulative volume delta broken down into supported exchanges. Viewable in dollar terms or standardized by the open interest for that coin on each exchange.
*Cumulative volume delta is the cumulative sum of (market buys minus market sells) for a coin over a given period.*
Average Return By Hour
The coin's average price change by hour of the day, shown in UTC time.
Average Return By Day
The coin's average price change by day of the week, with days defined in UTC time.
Cumulative Return By Session
The coin's cumulative open to close return by market session.
Sessions are defined as the following:
**US** - 8:00am to 6:00pm New York time
**EU** - 8:00am to 6:00pm Brussels time
**APAC** - 8:00am to 6:00pm Seoul time
Some overlap exists between sessions. Through volume analysis and consideration of local stock exchange hours, these windows were determined to be the best way to standardize 24 hours into equal length US, EU, and APAC trading sessions.
# Options
Velo uses [TradingView's](https://www.tradingview.com/) library to support seamless switching of coins and timeframes. Data updates live up to 5x per second and users may save up to 4 layouts that will persist across browser sessions, as well as display the chart in full screen.
*The charting technology is provided by TradingView, a platform for traders and investors. It offers advanced charting tools where people driven by markets can track major upcoming events in the* [*Economic calendar,*](https://www.tradingview.com/economic-calendar/) *chat, chart, and prepare for trades.*
DVOL
DVOL is Deribit's [implied volatility index](https://insights.deribit.com/exchange-updates/dvol-deribit-implied-volatility-index/). Velo displays the mark price of the index itself.
Price Overlay
Price overlay shows the mark price of the selected coin's perpetual future on Deribit.
Volume
Volume is viewable in contracts, notional, or premium terms, and in the form of call and put, call minus put, or total.
Contract volume is the actual number of contracts traded. Notional volume is the number of contracts traded times the price of each contract's underlying future. Premium is the dollar price of the option times the number of contracts traded.
Greeks
Greeks are calculated using the Black Scholes formula. Velo may price each option with a perpetual, dated, or interpolated underlying future.
* Traded amounts of delta are viewable in terms of coins or dollars, and in the form of call and put, call minus put, or total.
* Traded amounts of gamma are viewable in terms of coins or dollars.
* Traded amounts of vega are viewable in terms of coins or dollars.
RV
The realized volatility for the selected underlying (BTC or ETH), shown by default as 30 day realized volatility and with a spread to the DVOL index. The spread to DVOL is best viewed only when RV is kept as the default 30 day measure.
# Panels
The 6 charts beside the large TradingView chart on our Options page.
ATM Implied Volatility
Implied volatility is viewable standardized for options expiring in 1 week (7 days), 1 month (30 days), 3 months (90 days), or 6 months (180 days).
At the money implied volatility for each listed expiration is interpolated between the options with strike prices surrounding the price of the underlying future.
At the money implied volatility for each standardized expiration is interpolated between the values for expirations surrounding the target date.
*Saved and shown as a \~240 second moving average.*
25 Delta Skew
25 delta skew is viewable standardized for options expiring in 1 week (7 days), 1 month (30 days), 3 months (90 days), or 6 months (180 days).
25 delta put implied volatility for each listed expiration is interpolated between the options with deltas surrounding -0.25.
25 delta call implied volatility for each listed expiration is interpolated between the options with deltas surrounding 0.25.
25 delta skew for each listed expiration is calculated in the following manner:
* (25 delta put implied volatility - 25 delta call implied volatility) / at the money implied volatility
25 delta skew for each standardized expiration is interpolated between the values for expirations surrounding the target date.
*Saved and shown as a \~240 second moving average.*
Active Options
The 6 options contracts for the selected coin with the highest volume in the last 24 hours.
Put/Call
Volume: The trailing 24 hour options volume in contracts, broken down by put or call.
OI: The latest open interest in contracts for all options, broken down by put or call.
OI (Premium): The latest open interest in premium (OI \* option price in dollars) for all options, broken down by put or call.
Term Structure
The term structure with at the money and forward at the money implied volatility for each expiration on the selected coin.
Spot-Vol Correlation
The trailing correlation between changes in the DVOL index and changes in the underlying price for the selected coin.
Term Structure Slope
The spread between the 1 month at the money implied volatility and 6 month at the money implied volatility for the selected coin.
# Market
Users can filter most charts on this page to show only the coins on a selected watchlist. Custom watchlists can be made in the table on the [Chart](/web-app/chart) page.
Price Changes
Cumulative coin price changes, shown in percentages.
OI-Normalized CVD
Cumulative dollar volume delta across all supported exchanges for each coin, normalized by the aggregated open interest for that coin.
*Cumulative volume delta is the cumulative sum of (market buys minus market sells) for a coin over a given period.*
Funding Heatmap
The funding rates heatmap chart shows the evolution of coin funding rates over time. The rate shown for each period is an open-interest weighted average of a coin's funding rate (per 8 hours or per annum) for that period, across all supported exchanges.
Liquidations Heatmap
The liquidations heatmap chart shows historical coin liquidations. The value shown for each period is the total number of liquidations on a coin for that period, across all supported exchanges.
Open Interest Changes
Cumulative aggregated open interest (in coin terms) changes, shown in percentages.
Return Buckets
The return buckets chart breaks coins down to their percentage return over a selected time period. Each column shows the number of coins to fall into that bucket, and may list them on mouseover.
Market Volume
The total futures market dollar volume for all selected coins, grouped by exchange.
Total Open Interest
The total dollar open interest for all selected coins, grouped by exchange.
# TradFi
CME data will typically update as we receive it each day around 10:30pm ET.
*Coin values shown may differ from raw contract values. For example, one CME Bitcoin futures contract is equal to five Bitcoin.*
Open Interest
Futures: The summed open interest in coin or dollar terms across all CME Bitcoin futures contracts
Options: The summed open interest in coin or dollar terms across all CME Bitcoin options contracts
Volume
Futures: The summed volume in coin or dollar terms across all CME Bitcoin futures contracts
Options: The summed volume in coin or dollar terms across all CME Bitcoin options contracts
Basis
The annualized basis of the next-month CME futures contract for the selected coin.
*Calculated from daily settlement prices against Coinbase spot prices.*
GBTC/ETHE Premium
The premium or discount between the market price and NAV of the [Grayscale trust](https://www.grayscale.com/crypto-products) for the selected coin.
Implied price is also shown, calculated as (trust premium \* Coinbase spot price).
*Typically updates next-morning ET.*
# Alerts
On Velo, it is possible to create alerts for any of the combination below.
| Indicator | Direction | Unit | Timeframe | Crossing |
| ---------------------- | ------------------ | --------------- | ---------------------------- | --------------- |
| Price | Close | - | - | Up / Down / Any |
| ` Volume` | Total / Buy / Sell | Dollars / Coins | 1m / 5m / 15m / 1h / 4h / 1d | Up |
| ` Liquidations` | Total / Buy / Sell | Dollars / Coins | 1m / 5m / 15m / 1h / 4h / 1d | Up |
| ` Open Interest` | Close | Dollars / Coins | - | Up / Down / Any |
### Notifications
It is possible to get an alert notification through two different channels, either through the Velo web app or through Telegram. You can choose the notification channel when creating an alert.
#### Web notification
A web notification looks as follows and will trigger a sound effect as well. Upon clicking on the notification, you will be navigated to the symbol and timeframe.
#### Telegram notification
To enable Telegram notifications, you will need to connect your Velo account to the `Velo Alerts` bot.
After adding the bot through the deep link or the QR code, you should see the message:
```
Successfully linked chat to:
```
Alerts that are created with the Telegram option will now send a notification on Telegram app instead of the web app, when triggered.
### Tips for managing alerts
#### Create alerts with plus-menu
For a quicker way to create alerts, you can use TradingView's native plus-menu.
#### Drag-edit alerts
If you hold and drag an alert, you can quickly adjust the value in which it should trigger.
# VeloAI
**VeloAI is a conversational interface for crypto market data, currently in beta.**
Example Prompts
* What are the top performing coins this week?
* Which coins have a negative funding rate and a positive return today?
* Show me BTC open interest YTD.
* Show me ARB and OP price.
* Which coins have the most long liquidations this month?
* Which coins are up the most since BTC's low today?
* What are ETH IVs right now?
* Which coins have a market cap over $5B?
Reporting Mistakes
Should you suspect the AI has incorrectly interpreted one of your questions, you can help us improve the model by sending `!help [question]`.
Disclaimers
* Currently only UTC time is supported.
* The model has no memory between messages, meaning you need to type full queries each time.
# Borrow / Lend
To borrow stablecoins with HYPE as collateral, you will need to first add a Hyperliquid account to Velo. After a Hyperliquid account is added, the user's wallet can be connected and borrowing will be available to use.
Velo currently supports three lending protocols on the HyperEVM network:
* Felix
* Hyperlend
* Hyperdrive
The borrow UI in the Velo terminal is an interface for each protocol where the user directly interacts with the protocol's onchain contracts.
{% stepper %}
{% step %}
### Add a Hyperliquid account
Create or add your Hyperliquid account in Velo so the account is available for borrowing actions.
{% endstep %}
{% step %}
### Connect your wallet
After the Hyperliquid account is added, connect the user's wallet to enable borrowing through the Velo terminal.
{% endstep %}
{% endstepper %}
## Felix
The Felix lending market integrated with Velo is the [Felix Vanilla Markets](https://usefelix.gitbook.io/felix-docs/money-market-products/publish-your-docs), which is a deployment of the [Morpho Blue](https://docs.morpho.org/overview/concepts/market/) protocol.
On Morpho Blue (and hence on Felix Vanilla Markets as well), the positions are all isolated from each other. The collateral does not earn yield due the isolated model used, and borrow rates apply when borrowing assets.
### Health Factor
To avoid liquidation on your Felix Vanilla Market position, the health factor needs to be above `1.0`. Any health factor below `1.0` becomes eligeble for liquidation. More details can be found in the [Morpho documentation](https://docs.morpho.org/overview/concepts/liquidation/#health-factor).
{% hint style="info" %}
A position is healthy when the Health Factor is greater than 1.0. When it falls below 1.0, the position becomes eligible for liquidation.
*Source:* [*Morpho documentation*](https://docs.morpho.org/overview/concepts/liquidation/#health-factor)
{% endhint %}
## Hyperlend
Hyperlend is a fork of the [Aave V3](https://aave.com/docs/developers/aave-v3) contracts. This means that positions on Hyperlend share collaterals and borrows for all positions, and the collateral will earn supply yield and borrows have borrow rates that apply.
### Health Factor
While the UI only allows supplying and borrowing of singular assets, the health factor represents the aggregated health factor that will reflect the same value as the one in Hyperlend's website/contract.
To avoid liquidation on Hyperlend the health factor needs to be above `1.0`. Any health factor below `1.0` becomes eligeble for liquidation. More details can be found in the [Hyperlend documentation](https://docs.hyperlend.finance/hyperlend-1/liquidations).
{% hint style="info" %}
Liquidation occurs when a borrower's health factor falls below 1, indicating that their collateral value no longer sufficiently covers their loan/debt value. This situation can arise if the collateral decreases in value or the borrowed debt increases in value relative to each other. During a liquidation, a portion of the borrower's debt is repaid, and this amount plus a liquidation fee is deducted from the available collateral. Consequently, the liquidated debt portion is repaid.
*Source:* [*Hyperlend documentation*](https://docs.hyperlend.finance/hyperlend-1/liquidations)
{% endhint %}
## Hyperdrive
Hyperdrive's contracts are isolated borrowing markets, where collateral does not earn yield and where a borrow rate applies to borrows. The contracts are not open-source at the point of writing, and contracts have been audited.
### Health Factor
To avoid liquidation on Hyperlend the health factor needs to be above `100.0`. Any health factor below `100.0` becomes eligeble for liquidation. More details can be found in the [Hyperdrive documentation](broken://pages/6e8abf85005ed447e4b8202b2b072d107afba7d3). For Hyperdrive, there is a max health factor of `1000.0`.
{% hint style="info" %}
When your Health Score drops below 100 you are then exposed to the risk of being liquidated. It is therefore vital that you pay attention to your Health Score and when it gets too low, start to repay your liabilities or add more collateral to the market.
*Source:* [*Hyperdrive documentation*](https://hyperdrive-2.gitbook.io/hyperdrive/borrowing/liquidations#health-score-1)
{% endhint %}
# Manual Connection
To add a Hyperliquid account manually on Velo, navigate to the [API page](https://app.hyperliquid.xyz/API) on Hyperliquid. You will create an API wallet on Hyperliquid which will then be used to trade on Velo.
{% hint style="info" %}
An API wallet will never have access to the main wallet funds and will only have access to trading actions on Hyperliquid.
{% endhint %}
{% stepper %}
{% step %}
### Create an API wallet on Hyperliquid
* Enter a name for the API wallet (e.g. velo.xyz)
* Generate a new wallet
* Press the button "Authorize API Wallet" which will open up a popup
{% endstep %}
{% step %}
### In the authorization popup
* Enter any preferred expiration date on the API wallet (max 180 days)
* Save the API wallet private key
* Authorize the API wallet (this should prompt e.g. MetaMask for a signature to approve the API wallet)
{% endstep %}
{% step %}
### Add the API wallet to Velo
After the API wallet has been authorized, you'll need two values to enter into Velo:
* The master account address (NOTE: not the API wallet address — this is the master account address found at the top-right of the Hyperliquid UI)\
* The API wallet private key that was previously saved
Then:
* Accept the terms
* Press "Connect"
{% endstep %}
{% endstepper %}
# Terms of Service
**By connecting to Velo Trading, you accept that neither Velo nor the exchange are responsible for possible losses, our webapp saves your API keys on your device only, and Hyperliquid trades carry a builder fee of 0.01% (1 basis point). Please trade responsibly.**
By using Velo Data, you agree that:
* Your account and account information is for your own use only
* Your API key + data, derived data, and news from your API key are for your own use only
* If more than three IPs try to use the same account or API key within 5 minutes, only one may be allowed access
* API rate limit: 120 requests per 30 seconds
* Single requests return a max of [22.5k values](https://github.com/velodataorg/velo-node/blob/f5b00a589853e96b0f156ee23d1808721165ca20/lib/client.js#L87)
* Python and NodeJS libraries handle limiting/batching automatically
Please contact if you are interested in getting accounts or API keys for multiple people at your organization, or if you are interested in using our data or news for non-internal purposes.