Get user order events

curl --request GET \
  --url https://api.kuru.io/api/v3/{userAddress}/user/order-events

import requests

url = "https://api.kuru.io/api/v3/{userAddress}/user/order-events"

response = requests.get(url)

print(response.text)

const options = {method: 'GET'};

fetch('https://api.kuru.io/api/v3/{userAddress}/user/order-events', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.kuru.io/api/v3/{userAddress}/user/order-events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.kuru.io/api/v3/{userAddress}/user/order-events"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.kuru.io/api/v3/{userAddress}/user/order-events")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.kuru.io/api/v3/{userAddress}/user/order-events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

{
  "data": {
    "data": [
      {
        "eventType": "trade",
        "transactionHash": "0xdef456...",
        "blockTimestamp": "2024-01-28T12:00:00.000Z",
        "eventData": {
          "orderId": "0xabc...",
          "marketAddress": "0x111...",
          "marketId": 3,
          "owner": "0xabc123...",
          "orderSize": "1000000000000000000",
          "filledSize": "500000000000000000",
          "fillPrice": "49998000000000000000000",
          "updatedSize": "500000000000000000",
          "isBuy": false,
          "sizePrecision": "1000000000000000000",
          "pricePrecision": "10000",
          "baseFilled": "500000000000000000",
          "baseFilledInUsd": "24999000000000000000000",
          "baseToken": {
            "address": "0x...",
            "name": "Chog",
            "symbol": "CHOG",
            "decimal": 18,
            "logoUrl": "https://..."
          },
          "quoteToken": {
            "address": "0x...",
            "name": "USD Coin",
            "symbol": "USDC",
            "decimal": 6,
            "logoUrl": "https://..."
          }
        }
      }
    ],
    "pagination": {
      "total": 1,
      "page": 1,
      "pageSize": 50
    }
  }
}

{
  "error": "Invalid eventType: \"swap\". Must be one of: order-created, order-canceled, trade"
}

{
  "error": "Internal database or server error"
}

User Data

Get user order events

Lightweight endpoint designed for market makers. Returns order-related events only: order-created, order-canceled, and trade.

Events are sorted by blockTimestamp in descending order.

Cursoring guidance for high-volume market makers:

use timestamp windows (fromTimestamp, toTimestamp) as the primary cursor mechanism
persist the last processed event timestamp and query the next window using fromTimestamp
use limit only to cap payload size per request
avoid offset-based deep pagination for continuous polling on accounts with large event volume
when multiple events share the same second-level timestamp, re-query with a small overlap window and de-duplicate by (transactionHash, eventType, event-specific identifier)

Timestamp validation:

fromTimestamp and toTimestamp must be non-negative integers
when both are provided, fromTimestamp must be strictly less than toTimestamp

Cache behavior:

responses are cached in Redis with a 2-second TTL per unique parameter combination to minimize staleness for latency-sensitive consumers

Base-denomination convention:

computed amount fields (baseDeposited, baseFilled, basePositionValue) are always expressed in base token terms, regardless of isBuy
buy orders are normalized to base-equivalent position size

Response field denominations:

size, orderSize, filledSize, remainingSize, updatedSize — size precision units; divide by sizePrecision for human-readable base amount
baseDeposited, baseFilled, basePositionValue — raw base token units; divide by 10^decimal (base token) for human-readable amount
price (order-created, order-canceled) — price precision units; divide by pricePrecision for human-readable price
fillPrice (trade) — 1e18 precision; divide by 1e18 for human-readable price
*InUsd fields (baseDepositedInUsd, baseFilledInUsd, basePositionValueInUsd) — 1e18 precision; divide by 1e18 for USD value

GET

api

{userAddress}

user

order-events

Get user order events

curl --request GET \
  --url https://api.kuru.io/api/v3/{userAddress}/user/order-events

import requests

url = "https://api.kuru.io/api/v3/{userAddress}/user/order-events"

response = requests.get(url)

print(response.text)

const options = {method: 'GET'};

fetch('https://api.kuru.io/api/v3/{userAddress}/user/order-events', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.kuru.io/api/v3/{userAddress}/user/order-events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.kuru.io/api/v3/{userAddress}/user/order-events"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.kuru.io/api/v3/{userAddress}/user/order-events")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.kuru.io/api/v3/{userAddress}/user/order-events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

{
  "data": {
    "data": [
      {
        "eventType": "trade",
        "transactionHash": "0xdef456...",
        "blockTimestamp": "2024-01-28T12:00:00.000Z",
        "eventData": {
          "orderId": "0xabc...",
          "marketAddress": "0x111...",
          "marketId": 3,
          "owner": "0xabc123...",
          "orderSize": "1000000000000000000",
          "filledSize": "500000000000000000",
          "fillPrice": "49998000000000000000000",
          "updatedSize": "500000000000000000",
          "isBuy": false,
          "sizePrecision": "1000000000000000000",
          "pricePrecision": "10000",
          "baseFilled": "500000000000000000",
          "baseFilledInUsd": "24999000000000000000000",
          "baseToken": {
            "address": "0x...",
            "name": "Chog",
            "symbol": "CHOG",
            "decimal": 18,
            "logoUrl": "https://..."
          },
          "quoteToken": {
            "address": "0x...",
            "name": "USD Coin",
            "symbol": "USDC",
            "decimal": 6,
            "logoUrl": "https://..."
          }
        }
      }
    ],
    "pagination": {
      "total": 1,
      "page": 1,
      "pageSize": 50
    }
  }
}

{
  "error": "Invalid eventType: \"swap\". Must be one of: order-created, order-canceled, trade"
}

{
  "error": "Internal database or server error"
}

Path Parameters

userAddress

string

required

Ethereum address of the user (case-insensitive)

Example:

"0xabc123..."

Query Parameters

limit

integer

default:100

Maximum number of events to return in this window (payload cap, not a cursor)

Required range: x >= 1

Example:

50

offset

integer

default:0

Number of events to skip (legacy pagination; not recommended for high-volume market-maker polling)

Required range: x >= 0

Example:

0

marketAddress

string

Filter to a specific market contract address

Example:

"0x111..."

fromTimestamp

integer

Unix epoch in seconds; include events at or after this time (recommended cursor start)

Required range: x >= 0

Example:

1706400000

toTimestamp

integer

Unix epoch in seconds; include events at or before this time (recommended cursor end)

Required range: x >= 0

Example:

1706486400

eventType

enum<string>

Filter to a single event type

Available options:

order-created,

order-canceled,

trade

Example:

"trade"

Response

Successful response

data

object

required

Show child attributes

Get exchange information Get active user orders by market

⌘I

Kuru Exchange API

Kuru Exchange WebSocket Streams

TypeScript SDK

Python SDK

Kuru Flow API

Smart Contracts

Get user order events

Path Parameters

Query Parameters

Response