Kawbo · SaaS for algo traders

Mini SaaS for Quants: data platform.

This is a small API SaaS (in a beta-test mode for limited markets and pairs) for algo-traders, where both individual and institutional traders can effortlessly source realtime and historical market data with the highest level of granularity for backtest trading strategies against multiple cryptocurrency trading platforms and train their own AI models.

Our service serves a single purpose: it significantly reduces the time required to transition from the verification of trading hypotheses to profitable trading.

We operate a cluster of real-time market crawlers, recording millions events each day - every fluctuation in order books as well as trading histories. With our intuitive GraphQL API, order books can be easily reconstructed for specific moment in past time, allowing then for all events to be replayed and re-analyzed. This makes it an invaluable tool for accurate backtesting & debugging trading bot algorithms as well as using it as a data-source for machine learning and AI models.

Unlike many historical data providers, we give you access to the full history of market activity (every recorded buy and sell order with microsecond precision as well as trades), not just snapshots of market state.

Via our API, you can also query multi-venue order books combining orders from the markets you choose. This enables cross-exchange arbitrage strategies and tools for global liquidity analysis.

Connect an AI agent directly, over MCP or use API:

The same market data availiable both via API and via MCP endpoint, so your AI agent that speaks MCP - can query it for you. Add it as a custom connector with this URL:

The agent reads the schema in one call and then writes the GraphQL itself, so you can ask for an order book with markets to include or a slice of history in plain language.

There is a few simple examples how to use our GraphQL API in your implementation of trading strategy:

Subscribe for Realtime Combined Order Book from multiple markets limiting scope by target amount:

Try in Playground


subscription{
  orderBook(
    orderType: BIDS,
    baseAsset: "btc",
    quoteAsset: "usdt",
    markets: ["bitstamp", "binance"],
    targetCumulativeValue: 25000
  ) {
      cumulativeAmount,
      cumulativeValue,
      cumulativeNetValue,
      latestEventId,
      fulfilled,
      byOrders {
        takingAmount
        takingValue,
        cumulativeAmount,
        cumulativeValue,
        market,
        amount,
        value,
        netValue,
        price,
        feeAdjustedPrice,
        marketTimestamp
      }
    }
 }

You can also set how often backend will send your updates by setting a rateLimit.

Get the latest raw markets events:

Try in Playground


query{
  marketEvents(baseAsset: "eth", quoteAsset: "btc", maxElementsPerPage: 100){
    pageCursorFrom,
    pageCursorTo,
    eventsOnPage,
    events{
      __typename
	  ... on OrderEvent 
		{
    	  eventId,
          channel,
          diffType,
          amountChanged,
          baseAsset,
          quoteAsset,
          market,
          amount,
          amountChanged,
          price,
          marketTimestamp(format:POSIX_MILLISECOND),
          orderType
        }
  	  ... on TradeEvent 
		{
     	  baseAsset,
     	  quoteAsset,
     	  amount(
			filter: {rangeFilter: {rangeOperator: INCLUDE, rangeFrom: 0.1, rangeTo: 1.0}}
		  ),
     	  price,
     	  eventId,
          market,
          marketTimestamp,
          marketId,
          tradeType
  	    }
	}
  }
}

You can define what kind of events you want to fetch and even set a filters on per field basis. In a given example we want to include orders and trades, but trades only with amount between 0.1 and 1.0 ETH).

Reconstruct a Cross-Market Combined Order Book (ASKS Direction) for specific point of time:

Try in Playground


query {
  orderBook(
    orderType: ASKS,
    baseAsset: "btc",
    quoteAsset: "usdt",
    markets: ["bitstamp", "binance"],
    cursor: "2026-10-02T00:00:00Z",
    targetCumulativeAmount: 0.5,
  ) {
    cumulativeAmount,
    cumulativeValue,
    cumulativeNetValue,
    latestEventId,
    latestEventSystemTimestamp,
    fulfilled,
    byOrders {
      eventId,
      takingAmount,
      takingValue,
      cumulativeAmount,
      cumulativeValue,
      market,
      amount,
      value,
      netValue,
      price,
      feeAdjustedPrice,
      marketTimestamp
    }
  }
}

You can combine orderbooks from different markets with each other and even limiting the scope till how much amount or price orderbook will be traversed. Once you got the entry point - EventId from where you want to move Forward or Backward, you can move along by passing EventId as cursor and cursorShiftDirection for define walking direction.

Try to write other queries in our GraphQL API playground!

Our GraphQL schemas self documented and have a lot of features to cover many common use-cases scenarious.

We can also handle our customers special needs developing a tailored sulutions and API endpoints.