AI Picks & Recommendations

The AI resource exposes Mr. Doge's models: probabilistic picks with the data that drove them, plus recommendations filtered by edge and confidence.

Both methods require Business tier. Upgrade →

`ai.picks.list`

Paginated list of AI picks. Picks are multi-leg — each pick bundles one or more legs, each with its own outcome, odds, confidence, and rationale.

const { data, pagination } = await mrdoge.ai.picks.list({
  date: "2026-05-18",
  limit: 20,
});

for (const pick of data) {
  console.log(`Pick ${pick.id} · ${pick.pickType} · total ${pick.totalOdds}`);
  for (const leg of pick.legs) {
    console.log(`  → ${leg.outcome} @ ${leg.odds} (${leg.confidence})`);
    if (leg.edgePercentage != null) {
      console.log(`    edge: ${(leg.edgePercentage * 100).toFixed(1)}%`);
    }
    for (const reason of leg.rationale) {
      console.log(`    · ${reason}`);
    }
  }
}

Params:

Field	Type	Notes
`competitionIds`	`number[]`	Filter to one or more competitions
`regionIds`	`number[]`	Filter to one or more regions
`status`	`MatchStatus[]`	Filter by match phase
`date`	`string`	`YYYY-MM-DD`
`startDate` / `endDate`	`string`	Range filter
`cursor`	`string`	Pagination cursor
`limit`	`number`	Max 100
`locale`	`string`	`"en"`, `"pt-BR"`, `"es"`

Returns: { data: AiPick[]; pagination: { nextCursor, hasMore } }

The `AiPick` shape

type AiPick = {
  id: string;
  matchId: string;
  match?: Match;                    // optionally embedded summary
  pickType: string;                 // e.g. "single", "double", "accumulator"
  legs: PickLeg[];
  totalOdds: number;                // decimal odds for the whole bundle
  expiresAt: string;                // ISO timestamp
  settled: boolean;
  result: "won" | "lost" | "push" | null;
  createdAt: string;
};

type PickLeg = {
  marketId: string;
  outcome: string;                  // e.g. "Over 2.5", "Home Win"
  odds: number;                     // decimal odds
  point?: number | null;            // handicap line, e.g. 2.5
  confidence: "High" | "Medium" | "Low";
  edgePercentage?: number | null;   // 0.05 = 5%
  rationale: string[];              // localized reasoning bullets
};

`ai.picks.listAll`

Auto-paginated version. Same params as ai.picks.list minus cursor, returns a flat AiPick[].

const all = await mrdoge.ai.picks.listAll({
  date: "2026-05-18",
});

Supports onPage and signal like matches.listAll — see pagination.

`ai.recommendations.list`

Pre-filtered AI picks with edge and confidence thresholds applied. Use when you want the "best of" without scanning every pick.

const recs = await mrdoge.ai.recommendations.list({
  matchId: "match_abc123",
  minEdge: 0.05,          // 5% edge minimum
  confidence: "High",
  limit: 5,
});

Params:

Field	Type	Notes
`matchId`	`string`	Optional — filter to a single match
`confidence`	`"High" \| "Medium" \| "Low"`	Min confidence
`minEdge`	`number`	Min edge as a fraction (e.g. `0.05` = 5%)
`limit`	`number`	Max 100
`locale`	`string`	Localization

Returns: Recommendation[]

The `Recommendation` shape

type Recommendation = {
  id: string;
  matchId: string;
  match?: Match;
  marketId: string;
  betItemId?: string | null;
  outcome: string;
  odds: number;
  point?: number | null;
  confidence: "High" | "Medium" | "Low";
  edgePercentage: number;
  kellyFraction?: number;
  rationale: string[];
  riskFactors: string[];
  settled: boolean;
  result: "won" | "lost" | "push" | null;
  createdAt: string;
};

Unlike picks, recommendations are single-leg — one outcome per recommendation. They also expose riskFactors and kellyFraction for sizing.

Picks vs Recommendations

	`ai.picks.list`	`ai.recommendations.list`
Structure	Multi-leg bundles	Single outcomes
Filters by edge	No	Yes (`minEdge`)
Filters by confidence	No	Yes (`confidence`)
Includes risk factors	No	Yes (`riskFactors`)
Includes Kelly sizing	No	Yes (`kellyFraction`)
Use for	Full pick log, historical analysis	UI surfaces, trading triggers

Pattern: render the best picks for a match

const recs = await mrdoge.ai.recommendations.list({
  matchId: "match_abc123",
  minEdge: 0.03,
  limit: 10,
});

const sorted = recs.sort((a, b) => b.edgePercentage - a.edgePercentage);

for (const r of sorted) {
  console.log(
    `[${(r.edgePercentage * 100).toFixed(1)}%]`,
    r.outcome,
    `@ ${r.odds}`,
    `(${r.confidence})`,
  );
  r.rationale.forEach((line) => console.log(`  · ${line}`));
  if (r.riskFactors.length) {
    r.riskFactors.forEach((line) => console.log(`  risk: ${line}`));
  }
}

Matches →

The match objects that picks reference.

Tiers →

AI methods require Business and up.

Mr. Doge