Quickstart

from parlayx import KalshiOrderRequest, ParlayX, RequestError

client = ParlayX()

try:
    # Discovery is a chain: sports, then competitions, then events, then the
    # markets on an event.
    competitions = client.list_competitions(sport="spt_baseball").competitions
    competition = next((c for c in competitions if c.id == "cmp_mlb"), None) or competitions[0]

    events = client.list_events(competition_id=competition.id).events
    if not events:
        raise SystemExit("no events found")
    event = events[0]

    # An outcome carries one listing per venue that quotes it. Only an
    # `executable` listing can be ordered.
    listing = next(
        (
            listing
            for market in client.list_event_markets(event.id).markets
            for outcome in market.outcomes
            for listing in outcome.listings
            if listing.venue == "KALSHI" and listing.side == "YES" and listing.executable
        ),
        None,
    )
    if listing is None:
        raise SystemExit("no executable Kalshi YES listing found")

    submitted = client.kalshi.submit_order(
        KalshiOrderRequest(
            ticker=listing.ticker,
            # BID buys YES contracts; ASK sells them, which is also how you buy NO.
            side="BID",
            count="1",
            price="0.45",
        )
    )

    order = client.kalshi.get_order(submitted.order_id)
    print("order status:", order.status)
except RequestError as error:
    print(f"API error {error.status} ({error.code or 'unknown'}): {error.message}")

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.side === "YES" && l.executable);
  if (listing?.venue !== "KALSHI") throw new Error("no executable Kalshi YES listing found");

  const { orderId } = await client.kalshi.submitOrder({
    ticker: listing.ticker,
    /* BID buys YES contracts; ASK sells them, which is also how you buy NO. */
    side: "BID",
    count: "1",
    price: "0.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;
  }
}

# From discovery
listing.venue == "KALSHI"

# Straight to a stream subscription
await stream.subscribe([{"venue": listing.venue, "ticker": listing.ticker}])

/* From discovery */
listing.venue === "KALSHI";

/* Straight to a stream subscription */
stream.subscribe([{ venue: listing.venue, ticker: listing.ticker }]);

import uuid

idempotency_key = str(uuid.uuid4())

try:
    order = client.kalshi.submit_order(body, idempotency_key=idempotency_key)
except RequestError:
    order = client.kalshi.submit_order(body, idempotency_key=idempotency_key)

const idempotencyKey = crypto.randomUUID();

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

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

from parlayx import PolymarketMarketOrder

submitted = client.polymarket.submit_order(
    PolymarketMarketOrder(
        token_id="71045620195867637",
        side="BUY",
        type="MARKET",
        amount="5",
    )
)

client.polymarket.get_order_fills(submitted.order_id)
client.polymarket.list_positions()
client.kalshi.get_balance()

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();

identity = client.whoami()
server_time = client.get_time().time

const identity = await client.whoami();
const { time } = await client.getTime();