Method Reference

async createVerdict(params: CreateDebateParams): Promise<CreateDebateResult>

async getVerdict(id: string): Promise<{ verdict: DebateResponse }>

async listVerdicts(params?: ListDebatesParams): Promise<ListDebatesResult>

async deleteVerdict(id: string): Promise<void>

await client.deleteVerdict("dbt_abc123");
// Resolves with void; throws AskVerdictError on failure

async *streamVerdict(id: string): AsyncGenerator<StreamEvent>

async getVotes(debateId: string): Promise<VoteMap>

const votes = await client.getVotes("dbt_abc123");
 
for (const [claimId, tally] of Object.entries(votes)) {
  console.log(`${claimId}: +${tally.agree} / -${tally.disagree}`);
  if (tally.userVote) {
    console.log(`  Your vote: ${tally.userVote}`);
  }
}

async castVote(debateId: string, claimId: string, vote: VoteValue): Promise<void>

async removeVote(debateId: string, claimId: string): Promise<void>

await client.removeVote("dbt_abc123", "claim_xyz");

async getPolls(debateId: string): Promise<Poll[]>

const polls = await client.getPolls("dbt_abc123");
 
for (const poll of polls) {
  console.log(`${poll.question} (${poll.status})`);
  for (const option of poll.options) {
    const votes = poll.tallies[option.id] ?? 0;
    console.log(`  ${option.label}: ${votes} votes`);
  }
}

async createPoll(debateId: string, question: string, options: string[]): Promise<Poll>

const poll = await client.createPoll(
  "dbt_abc123",
  "Which argument was most convincing?",
  ["The pro side — scalability wins", "The con side — cost is too high", "Neither"],
);
 
console.log(poll.id); // "poll_pqr789"

async votePoll(debateId: string, pollId: string, optionId: string): Promise<void>

await client.votePoll("dbt_abc123", "poll_pqr789", "opt_001");

async closePoll(debateId: string, pollId: string): Promise<void>

await client.closePoll("dbt_abc123", "poll_pqr789");

async deletePoll(debateId: string, pollId: string): Promise<void>

await client.deletePoll("dbt_abc123", "poll_pqr789");

async getOutcome(debateId: string): Promise<OutcomeRecord>

const outcome = await client.getOutcome("dbt_abc123");
 
if (outcome.verdictWasCorrect !== null) {
  console.log(`Verdict was ${outcome.verdictWasCorrect ? "correct" : "incorrect"}`);
}

async submitOutcome(debateId: string, params: SubmitOutcomeParams): Promise<OutcomeRecord>

async getPendingOutcomes(): Promise<OutcomeRecord[]>

const pending = await client.getPendingOutcomes();
 
console.log(`${pending.length} debates awaiting outcome recording`);
for (const p of pending) {
  console.log(p.debateId);
}

async getOutcomeHistory(
  opts?: { limit?: number; offset?: number; domain?: string }
): Promise<OutcomeRecord[]>

const history = await client.getOutcomeHistory({ limit: 50, domain: "business" });

async getBalance(): Promise<BalanceInfo>

const balance = await client.getBalance();
 
console.log(`${balance.creditBalance} credits remaining on the ${balance.plan} plan`);

async search(query: string, opts?: SearchParams): Promise<SearchResult>

async getMe(): Promise<UserProfile>

const me = await client.getMe();
console.log(`Hello, ${me.name} (${me.plan} plan)`);

async getUsage(): Promise<UsageInfo>

const usage = await client.getUsage();
const cap = usage.debatesLimit ?? "unlimited";
console.log(`${usage.debatesThisMonth} / ${cap} debates this month`);

async getApiUser(): Promise<UserProfile>

const user = await client.getApiUser();

async getApiUsage(): Promise<ApiKeyUsage>

const usage = await client.getApiUsage();
console.log(`${usage.totalRequests} total API requests this period`);

async getDashboard(workspaceId?: string): Promise<DashboardStats>

const stats = await client.getDashboard();
console.log(`${stats.totalDebates} debates total, ${stats.currentStreak} day streak`);

async getScore(): Promise<DecisionScore>

const score = await client.getScore();
console.log(`Accuracy: ${Math.round(score.overallAccuracy * 100)}%`);

async getStreak(): Promise<StreakInfo>

const streak = await client.getStreak();
console.log(`Current streak: ${streak.currentStreak} days`);
console.log(`Longest ever: ${streak.longestStreak} days`);

async health(): Promise<HealthResponse>

const client = new AskVerdictClient(); // no auth needed
const health = await client.health();
 
if (health.status !== "ok") {
  console.warn(`API is ${health.status}`);
}

import { AskVerdictClient, AskVerdictError } from "@askverdict/sdk";
 
const client = new AskVerdictClient({ apiKey: process.env.ASKVERDICT_API_KEY });
 
try {
  const result = await client.createVerdict({ question: "..." });
} catch (error) {
  if (error instanceof AskVerdictError) {
    console.error(`[${error.code}] ${error.message}`);
    // error.status  → HTTP status (401, 422, 429, etc.)
    // error.details → extra context from the API
  } else {
    throw error; // re-throw unexpected errors
  }
}