Quickstart

This walks the full path: find an event, pick an outcome, submit an order, and read it back. Resource methods return the typed payload directly and throw a RequestError on any non-2xx response.

import { createClient, RequestError } from "@parlayx/sdk";

const client = createClient({
  keyId: process.env.PARLAYX_KEY_ID!,
  privateKeyHex: process.env.PARLAYX_PRIVATE_KEY_HEX!,
});

try {
  /* Discovery is a chain: sports, then competitions, then events, then the
     markets on an event. */
  const { competitions } = await client.listCompetitions({ sport: "spt_baseball" });
  const competition = competitions.find((c) => c.id === "cmp_mlb") ?? competitions[0];
  if (!competition) throw new Error("no competition found");

  const { events } = await client.listEvents({ competitionId: competition.id });
  const event = events[0];
  if (!event) throw new Error("no events found");

  /* An outcome carries one listing per venue that quotes it. Only an
     `executable` listing can be ordered. */
  const { markets } = await client.listEventMarkets(event.id);
  const listing = markets
    .flatMap((market) => market.outcomes)
    .flatMap((outcome) => outcome.listings)
    .find((l) => l.venue === "KALSHI" && l.executable);
  if (listing?.venue !== "KALSHI") throw new Error("no executable Kalshi listing found");

  const { orderId } = await client.kalshi.submitOrder({
    ticker: listing.ticker,
    side: listing.side,
    action: "BUY",
    count: 1,
    priceCents: 45,
    timeInForce: { type: "GTC" },
  });

  const order = await client.kalshi.getOrder(orderId);
  console.log("order status:", order.status);
} catch (error) {
  if (error instanceof RequestError) {
    console.error(`API error ${error.status} (${error.code ?? "unknown"}): ${error.message}`);
  } else {
    throw error;
  }
}

submitOrder attaches a fresh idempotency key to every call, which protects you from the API replaying one request twice. It does not make your retry safe: a second call without a key of your own carries a new one, and the API treats it as a new order. To make a retry safe, generate the key yourself, keep it for as long as you might retry, and send the same one every time:

const idempotencyKey = crypto.randomUUID();

const submit = () => client.kalshi.submitOrder(body, { idempotencyKey });

const order = await submit().catch(submit);

Re-sending a key with the same body returns the original order and creates no duplicate. Re-sending it with a different body is rejected. If a submit fails in a way that leaves the outcome unknown, you get ORDER_RECONCILIATION_REQUIRED: read the order back rather than submitting again.

Venue namespaces

Orders, positions and balances are venue-scoped, because the venues address markets differently: Kalshi by ticker with a YES/NO side and integer priceCents, Polymarket by tokenId with BUY/SELL and decimal prices.

const { orderId } = await client.polymarket.submitOrder({
  tokenId: "71045620195867637",
  side: "BUY",
  type: "MARKET",
  amount: "5",
  timeInForce: { type: "FOK" },
});

await client.polymarket.getOrderFills(orderId);
await client.polymarket.listPositions();
await client.kalshi.getBalance();

Each namespace carries the same seven methods: submitOrder, listOrders, getOrder, cancelOrder, getOrderFills, listPositions and getBalance.

Identity and clock

client.whoami() returns the actor and pod your key acts for, plus its scope and capabilities, which is useful for confirming a key is wired to the pod you expect. client.getTime() returns the server clock; see Authentication on why that matters.

TypeScript SDK

Streaming

Venue namespaces

Identity and clock

​Venue namespaces

​Identity and clock

Venue namespaces

Identity and clock