TypeScript SDK

const markets = client.listMarkets({
  closed: false,
  pageSize: 10,
});

for await (const page of markets) {
  // page.items: Market[]
}

const teams = client.listTeams({
  league: ["NBA"],
  pageSize: 10,
});

for await (const page of teams) {
  // page.items: Team[]
}

const tags = client.listTags({
  pageSize: 10,
});

for await (const page of tags) {
  // page.items: Tag[]
}

const tag = await client.fetchTag({
  slug: "politics",
});

const relatedTags = await client.fetchRelatedTags({
  slug: "politics",
});

const relatedResources = await client.fetchRelatedTagResources({
  slug: "politics",
  status: "active",
});

const comments = client.listComments({
  parentEntityId: "12345",
  parentEntityType: "Event",
  pageSize: 20,
});

for await (const page of comments) {
  // page.items: Comment[]
}

const thread = await client.fetchCommentsById({
  id: "456",
  getPositions: true,
});

const userComments = client.listCommentsByUserAddress({
  address: "0x1234…",
  pageSize: 10,
  order: "DESC",
});

for await (const page of userComments) {
  // page.items: Comment[]
}

const sports = await client.listSports();

// sports: SportsMetadata[]

const results = client.search({
  q: "ethereum",
  pageSize: 10,
});

for await (const page of results) {
  // page.items.events: Event[]
  // page.items.tags: SearchTag[]
  // page.items.profiles: Profile[]
}

import { OrderSide } from "@polymarket/client";

const response = await secureClient.placeLimitOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.SELL,
  price: 0.52,
  size: 10,
  expiration: Math.floor(Date.now() / 1000) + 60 * 60,
});

if (response.ok) {
  // response.orderId: string
} else {
  // response.code: OrderResponseErrorCode
  // response.message: string
}

import { OrderSide, OrderType } from "@polymarket/client";

const response = await secureClient.placeMarketOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.BUY,
  amount: 10,
  maxSpend: 11,
  orderType: OrderType.FAK,
});

if (response.ok) {
  // response.orderId: string
} else {
  // response.code: OrderResponseErrorCode
  // response.message: string
}

import { OrderSide, OrderType } from "@polymarket/client";

const response = await secureClient.placeMarketOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.SELL,
  shares: 10,
  orderType: OrderType.FOK,
});

if (response.ok) {
  // response.orderId: string
} else {
  // response.code: OrderResponseErrorCode
  // response.message: string
}

import { OrderSide } from "@polymarket/client";

const response = await secureClient.placeLimitOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.BUY,
  price: 0.52,
  size: 10,
  builderCode: "0xabc123…",
});

if (response.ok) {
  // response.orderId: string
} else {
  // response.code: OrderResponseErrorCode
  // response.message: string
}

import { OrderSide } from "@polymarket/client";

const firstOrder = await secureClient.createLimitOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.BUY,
  price: 0.52,
  size: 10,
});

const secondOrder = await secureClient.createLimitOrder({
  tokenId: market.outcomes.yes.tokenId!,
  side: OrderSide.SELL,
  price: 0.58,
  size: 5,
});

const responses = await secureClient.postOrders([firstOrder, secondOrder]);

for (const response of responses) {
  if (response.ok) {
    // response.orderId: string
  } else {
    // response.code: OrderResponseErrorCode
    // response.message: string
  }
}

const handle = await secureClient.mergePositions({
  conditionId: market.conditionId!,
  amount: "max",
});

const outcome = await handle.wait();

// outcome.transactionHash: TxHash

const handle = await secureClient.redeemPositions({
  marketId: market.id,
});

const outcome = await handle.wait();

// outcome.transactionHash: TxHash

const openOrders = secureClient.listOpenOrders({
  market: market.id, // Or market.conditionId
});

for await (const page of openOrders) {
  // page.items: OpenOrder[]
}

const response = await secureClient.cancelOrder({
  orderId,
});

// response.canceled: string[]

const response = await secureClient.cancelMarketOrders({
  tokenId: market.outcomes.yes.tokenId!,
});

// response.canceled: string[]

const rewards = client.listMarketRewards({
  conditionId: market.conditionId!,
});

for await (const page of rewards) {
  // page.items: MarketReward[]
}

const scoring = await secureClient.fetchOrderScoring({
  orderId,
});

// scoring: boolean

const scoring = await secureClient.fetchOrdersScoring({
  orderIds: [firstOrderId, secondOrderId],
});

// scoring: OrdersScoringResponse

const value = await secureClient.fetchPortfolioValue({
  market: [market.id], // Or market.conditionId
});

// value: Value[]

import { ActivityType } from "@polymarket/client";

const activity = secureClient.listActivity({
  market: [market.id], // Or market.conditionId
  pageSize: 10,
});

for await (const page of activity) {
  for (const item of page.items) {
    switch (item.type) {
      case ActivityType.TRADE:
        // item.tokenId: TokenId
        // item.shares: DecimalString
        break;
      case ActivityType.REWARD:
        // item.amount: DecimalString
        break;
      default:
      // …
    }
  }
}

const yesTokenId = market.outcomes.yes.tokenId!;

const trades = secureClient.listAccountTrades({
  tokenId: yesTokenId,
});

for await (const page of trades) {
  // page.items: ClobTrade[]
}

const notifications = await secureClient.fetchNotifications();

// notifications: Notification[]

const credentials = await storage.get("polymarketCredentials");

const secureClient = await createSecureClient({
  wallet: "YOUR_POLYMARKET_WALLET_ADDRESS",
  signer,
  credentials,
});