Kiyotaka: API Documentation

• wss://api.kiyotaka.ai/v2/ - WebSocket API

  Provides a WebSocket JSON-RPC interface. Uses JSON-RPC streaming and requires periodic ping messages to maintain the connection.

• https://api.kiyotaka.ai/v1/ - REST API

  Offers a RESTful API interface. For detailed API specifications, refer to the Swagger documentation.

• grpc.api.kiyotaka.ai:443 - gRPC API

  Offers a gRPC API interface. Includes streaming methods.

• /docs/ - Methods and Type Documentation

  Provides comprehensive documentation for all API methods and data types.

• /swagger/ - Swagger UI

  Interactive interface to explore and test the REST API endpoints.

• /proto/ - .proto files

  List of gRPC protobuf files used by the current server.

  Useful for generating client code.

• github.com/kiyotaka-ai/kiyotaka-api-py - Python SDK

  Python SDK based on .proto files.

• github.com/kiyotaka-ai/kiyotaka-api-js - JavaScript/TypeScript SDK

  JavaScript/TypeScript SDK based on .proto files.

Index

Restrictions

• PointType.TRADE is available only for the last 24 hours

• x-kiyotaka-key header with the API key is required

• no rate limiting

Examples

• Get candlesticks for BTCUSDT on COINBASE

  https://api.kiyotaka.ai/v1/points?type=TRADE_AGG&exchange=COINBASE&symbol=BTCUSDT&interval=MINUTE&period=3600

• Get all coins on all exchanges

  https://api.kiyotaka.ai/v1/coins?type=TRADE_AGG

• python: StreamPoints

  This snippet demonstrates how to use the Kiyotaka API to stream trade aggregation data for Bitcoin from Binance.
  It connects to the API via gRPC, requests data for the last hour, and prints the JSON responses as they are received.
  
  

  import asyncio
  import kiyotaka
  import kiyotaka.api
  import time
  
  from grpclib.client import Channel
  
  async def main():
      metadata = {
          'x-kiyotaka-key': 'YOUR_API_KEY_HERE'
      }
  
      channel = Channel(
          host="grpc.api.kiyotaka.ai",
          port=443,
          ssl=True,
      )
      service = kiyotaka.api.ApiStub(channel)
  
      from_ = int(time.time()) - 60*60
  
      data_request = kiyotaka.api.PointRequest(
          type=[kiyotaka.api.PointType.TRADE_AGG],
          exchange=[kiyotaka.api.PointExchange.BINANCE],
          coin=["BTC"],
          interval=kiyotaka.api.PointAggregationInterval.MINUTE,
          from_=from_,
      )
  
      stream = service.stream_points(data_request, timeout=3600, metadata=metadata)
      async for response in stream:
          print(response.to_json())
  
      channel.close()
  
  if __name__ == "__main__":
      asyncio.run(main())
  

• typescript: StreamPoints

  import { api } from "../kiyotaka/api/api";
  import * as grpc from "@grpc/grpc-js";
  
  async function main() {
    const metadata = new grpc.Metadata();
    metadata.set("x-kiyotaka-key", "YOUR_API_KEY_HERE");
  
    const client = new api.APIClient(
      "grpc.api.kiyotaka.ai:443",
      grpc.credentials.createSsl()
    );
  
    const from = Math.floor(Date.now() / 1000) - 60 * 60;
    const request = new api.PointRequest({
      type: [api.PointType.TRADE_AGG],
      exchange: [api.PointExchange.BINANCE],
      coin: ["BTC"],
      interval: api.PointAggregationInterval.MINUTE,
      from: from,
    });
  
    const stream = client.StreamPoints(request, metadata);
  
    stream.on("data", (response: api.PointSeries) => {
      console.log(JSON.stringify(response.toObject()));
    });
  
    stream.on("error", (error: Error) => {
      console.error("Stream error:", error);
    });
  
    stream.on("end", () => {
      console.log("Stream ended");
      client.close();
    });
  }
  
  main().catch(console.error);
  

API

API service for querying and streaming financial data points

Methods with HTTP bindings

Point

Represents a single data point

PointMetaRequest

PointMetaResponse

PointRequest

PointResponse

Response containing series of data points

PointSeries

Represents a series of data points

PointSeriesIdentifier

PointAggregationInterval

PointCategory

Enum representing different categories of financial instruments

PointExchange

Enum representing different exchanges

PointSide

Enum representing trade sides

PointType

Enum representing different types of data points

TradeAggregation

Represents aggregated trade data for a specific time period

TradeSideAgnosticAggregation

Represents aggregated trade data for a specific time period, but without Side

grouping

OpenInterestAggregation

FundingRateAggregation

LiquidationAggregation

CmeOpenInterestAggregation

OptionOpenInterestAggregation

HyperliquidLiquidationAggregation

Timestamp

Timestamp is a point in time represented as seconds and fractions of seconds at nanosecond resolution in UTC since Unix epoch.

Trade

Represents a single trade transaction