Getting Started

signature = HMAC-SHA256(
  key: api_secret,
  message: timestamp + method + path + body
)

import crypto from 'node:crypto';

function signRequest(
  apiSecret: string,
  method: string,
  path: string,
  body: string = ''
): { timestamp: string; signature: string } {
  const timestamp = String(Date.now());
  const message = timestamp + method.toUpperCase() + path + body;
  const signature = crypto
    .createHmac('sha256', apiSecret)
    .update(message)
    .digest('hex');

  return { timestamp, signature };
}

// Usage
const { timestamp, signature } = signRequest(
  process.env.LIQUIDITYIO_API_SECRET!,
  'GET',
  '/v1/ticker/BTC-USD'
);

const response = await fetch('https://api.liquidity.io/v1/ticker/BTC-USD', {
  headers: {
    'X-API-KEY': process.env.LIQUIDITYIO_API_KEY!,
    'X-TIMESTAMP': timestamp,
    'X-SIGNATURE': signature,
  },
});

#!/bin/bash
API_KEY="your-api-key"
API_SECRET="your-api-secret"
BASE_URL="https://api.liquidity.io/v1"

TIMESTAMP=$(date +%s%3N)
METHOD="GET"
PATH="/v1/ticker/BTC-USD"
BODY=""

SIGNATURE=$(echo -n "${TIMESTAMP}${METHOD}${PATH}${BODY}" \
  | openssl dgst -sha256 -hmac "${API_SECRET}" -hex | awk '{print $2}')

curl -H "X-API-KEY: ${API_KEY}" \
     -H "X-TIMESTAMP: ${TIMESTAMP}" \
     -H "X-SIGNATURE: ${SIGNATURE}" \
     "${BASE_URL}/ticker/BTC-USD"

X-RateLimit-Limit: 120
X-RateLimit-Remaining: 118
X-RateLimit-Reset: 1742400060

npm install @liquidityio/trading

import { Client, Config, NativeVenueConfig } from '@liquidityio/trading';

const config = new Config()
  .withNative('liquidity', NativeVenueConfig.liquidDex('https://api.liquidity.io/v1'))
  .withVenuePriority(['liquidity']);

const client = new Client(config);
await client.connect();

const order = await client.buy('AAPL', 10);
console.log(`Filled at ${order.average_price}`);

await client.disconnect();

pip install lx-trading

import asyncio
from decimal import Decimal
from lx_trading import Client, Config
from lx_trading.config import NativeVenueConfig

async def main():
    config = Config()
    config.with_native("liquidity", NativeVenueConfig.liquid_dex("https://api.liquidity.io/v1"))

    client = Client(config)
    await client.connect()

    order = await client.buy("AAPL", Decimal("10"))
    print(f"Filled at {order.average_price}")

    await client.disconnect()

asyncio.run(main())

go get github.com/liquidityio/dex/sdk/go

package main

import (
    "fmt"
    "log"

    lxdex "github.com/liquidityio/dex/sdk/go"
)

func main() {
    client := lxdex.NewClient(lxdex.Config{
        APIURL:    "https://api.liquidity.io/v1",
        APIKey:    "your-api-key",
        APISecret: "your-api-secret",
    })

    order, err := client.PlaceOrder("AAPL", "buy", "market", 0, 10)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Filled at %v\n", order.AveragePrice)
}

[dependencies]
liquidityio-trading = "0.1"

use liquidityio_trading::{Client, Config, NativeVenueConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::new()
        .with_native("liquidity", NativeVenueConfig::liquid_dex("https://api.liquidity.io/v1"))
        .with_api_key("your-api-key");

    let client = Client::new(config);
    client.connect().await?;

    let order = client.buy("AAPL", 10.0).await?;
    println!("Filled at {}", order.average_price);

    Ok(())
}

#include <liquidityio/trading.h>
#include <iostream>

int main() {
    auto config = lx::Config()
        .withNative("liquidity", lx::NativeVenueConfig::liquidDex("https://api.liquidity.io/v1"))
        .withApiKey("your-api-key");

    auto client = lx::Client(config);
    client.connect();

    auto order = client.buy("AAPL", 10);
    std::cout << "Filled at " << order.averagePrice << std::endl;

    return 0;
}

export LIQUIDITYIO_API_KEY="your-api-key"
export LIQUIDITYIO_API_SECRET="your-api-secret"
export LIQUIDITYIO_API_URL="https://api.next.liquidity.io/v1"  # sandbox

npm install @liquidityio/trading

import { DEX } from '@liquidityio/trading';

const dex = await DEX({
  rpcUrl: process.env.LIQUIDITYIO_API_URL!,
  apiKey: process.env.LIQUIDITYIO_API_KEY!,
});

// Check the price
const ticker = await dex.ticker('BTC-USD');
console.log(`BTC-USD: bid=${ticker.bid} ask=${ticker.ask}`);

// Place a small market buy (sandbox)
const order = await dex.buy('BTC-USD', '0.001');
console.log(`Order ${order.orderId}: ${order.status}`);
console.log(`Filled ${order.filledQuantity} at ${order.averagePrice}`);

npx tsx first-trade.ts

# Get BTC-USD quote
TIMESTAMP=$(date +%s%3N)
SIGNATURE=$(echo -n "${TIMESTAMP}GET/v1/ticker/BTC-USD" \
  | openssl dgst -sha256 -hmac "$LIQUIDITYIO_API_SECRET" -hex | awk '{print $2}')

curl -s -H "X-API-KEY: $LIQUIDITYIO_API_KEY" \
     -H "X-TIMESTAMP: $TIMESTAMP" \
     -H "X-SIGNATURE: $SIGNATURE" \
     "$LIQUIDITYIO_API_URL/ticker/BTC-USD" | jq .

{
  "symbol": "BTC-USD",
  "bid": "84248.00",
  "ask": "84252.00",
  "last": "84250.00",
  "volume24h": "1234.56",
  "timestamp": 1742400000000
}