You've built a Polymarket trading bot. It checks odds, evaluates volume, sets position sizes, and enters markets automatically. It's making money.

But it has a blind spot.

Your bot doesn't know that "Will there be a ceasefire in Ukraine?" has a 75% chance of being disputed. It doesn't know that ambiguous question wording can freeze your capital for weeks. It treats every market the same way — and some of those markets are ticking time bombs.

Here's how to add dispute risk screening to your bot in 5 minutes.

The Problem

Polymarket uses the UMA optimistic oracle for market resolution. When a market's resolution criteria are ambiguous, anyone can dispute the proposed outcome. During a dispute:

• Your capital is frozen
• The resolution takes days to weeks
• The outcome is decided by UMA token holders, not market experts

In our dataset of 164K+ scored markets, markets with ambiguous criteria get disputed at 8.2x the baseline rate. Your bot doesn't check for this. Neither does anyone else's.

The Fix: OracleMangle API

Add one API call before your bot enters a position. If the dispute risk is above your threshold, skip the market.

Quick Start (Python)

import requests

ORACLEMANGLE_API_KEY = "your_api_key_here"
RISK_THRESHOLD = 0.25  # Skip markets above 25% dispute risk

def check_dispute_risk(condition_id: str) -> dict:
    """Check dispute risk for a Polymarket market."""
    resp = requests.get(
        f"https://api.oraclemangle.com/v1/markets/{condition_id}",
        headers={"X-API-Key": ORACLEMANGLE_API_KEY},
        timeout=5,
    )
    resp.raise_for_status()
    return resp.json()

def should_enter_market(condition_id: str) -> bool:
    """Returns True if the market is safe to trade."""
    risk = check_dispute_risk(condition_id)

    if risk["dispute_risk"] > RISK_THRESHOLD:
        print(f"SKIP: {risk['question'][:60]}... "
              f"(risk: {risk['dispute_risk']:.0%})")
        return False

    return True

# In your main trading loop:
for market in get_open_markets():
    if not should_enter_market(market.condition_id):
        continue  # Skip high-risk markets

    # Your existing trading logic
    evaluate_odds(market)
    size_position(market)
    enter_trade(market)

That's it. Three lines added to your existing bot: import, check, skip.

API Response Format

{
    "id": "0x1234...abcd",
    "question": "Will there be a ceasefire in Ukraine before March 2026?",
    "platform": "polymarket",
    "dispute_risk": 0.75,
    "yes_price": 0.42,
    "volume_24h": 185000.0,
    "close_time": "2026-03-01T00:00:00Z",
    "fetched_at": "2026-04-14T10:30:00Z",
    "safe_to_trade": false
}

Portfolio Screening

Screen your portfolio by querying high-risk markets and cross-referencing with your positions:

def get_high_risk_markets(min_risk: float = 0.25) -> list[dict]:
    """Get all markets above a risk threshold."""
    resp = requests.get(
        "https://api.oraclemangle.com/v1/markets",
        headers={"X-API-Key": ORACLEMANGLE_API_KEY},
        params={"min_risk": min_risk, "limit": 500},
        timeout=15,
    )
    resp.raise_for_status()
    return resp.json()

# Check if any of your positions are in high-risk markets
my_positions = get_my_positions()  # Your function
my_ids = {p.condition_id for p in my_positions}

risky = get_high_risk_markets(min_risk=0.25)
for market in risky:
    if market["id"] in my_ids:
        print(f"WARNING: Position in high-risk market: "
              f"{market['question'][:50]}... ({market['dispute_risk']:.0%})")

Score Any Question On Demand

Test a custom question before a market even exists:

def score_question(question: str) -> dict:
    """Score any question text via Gemini Flash."""
    resp = requests.get(
        "https://api.oraclemangle.com/v1/score",
        headers={"X-API-Key": ORACLEMANGLE_API_KEY},
        params={"question": question},
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()

result = score_question("Will there be a ceasefire in Ukraine before 2027?")
# → {"dispute_risk": 0.72, "safe_to_trade": false,
#    "key_factors": ["subjective definition of ceasefire", ...],
#    "reasoning": "No universally agreed definition of ceasefire..."}

Poll Alerts

Check for recent alerts from the alert engine:

def get_recent_alerts(limit: int = 20, alert_type: str = None) -> list[dict]:
    """Fetch recent alerts with NL explanations."""
    params = {"limit": limit}
    if alert_type:
        params["alert_type"] = alert_type
    resp = requests.get(
        "https://api.oraclemangle.com/v1/alerts",
        headers={"X-API-Key": ORACLEMANGLE_API_KEY},
        params=params,
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

What the Risk Score Means

The Numbers

Our model is trained on 164K+ historical markets and validated against 1,654 actual disputes:

• AUC-ROC: 0.80 (benchmarked against Gemini Flash, Claude Sonnet, Kimi K2, Llama 4)
• Monotonic calibration: Higher scores = more disputes, in every risk bucket
• Average API response time: 200ms
• Cost per query: Included in your plan (no per-query charges)

Getting API Access

The API is available on the Institutional plan ($299/mo, 30-day free trial). This includes: - Unlimited API queries - Batch endpoints - Webhook push - Direct support

For individual traders who don't need an API, the Telegram bot (@OracleManglebot) provides the same risk scores in a human-readable format. Free tier available.

Get Started

1. Message @OracleManglebot on Telegram
2. Request API access (mention you're a bot developer)
3. Get your API key
4. Add the 3 lines of code above to your bot

Your bot will never blindly enter a disputed market again.

OracleMangle — dispute risk intelligence for prediction markets. GitHub | Telegram | API Docs