Supported AI Models

Overview

CheckThat AI supports 18+ state-of-the-art AI models from 5 major providers. All models support claim normalization, with most supporting structured outputs, refinement, and evaluation.

Model routing is handled automatically by the LLMRouter class in api/_utils/LLMRouter.py, which detects the provider and initializes the appropriate API client.

Supported Providers

OpenAI

GPT-5, GPT-4, o3, o4-miniBest for: Production use, balanced performance

Anthropic

Claude Sonnet 4, Claude Opus 4.1Best for: High-quality claims, nuanced understanding

Google

Gemini 2.5 Pro, Gemini 2.5 FlashBest for: Fast inference, cost-effectiveness

xAI

Grok 3, Grok 4, Grok 3 MiniBest for: Real-time claims, current events

Meta (via Together AI)

Llama 3.3 70B TurboBest for: Open-source, customization

DeepSeek (via Together AI)

DeepSeek R1 Distill Llama 70BBest for: Research, reasoning tasks

Complete Model List

OpenAI Models

gpt-5-2025-08-07

GPT-5

Display Name: GPT-5OpenAI’s latest flagship model with enhanced reasoning and claim understanding.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: High-stakes fact-checking, complex claims, production workloadsCost: Premium

gpt-5-nano-2025-08-07

GPT-5 nano

Display Name: GPT-5 nanoEfficient version of GPT-5 optimized for speed and cost.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: High-volume processing, cost-sensitive applicationsCost: Moderate

o3-2025-04-16

Display Name: o3OpenAI’s reasoning model with advanced chain-of-thought capabilities.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
⚠️ Streaming (limited)

Use Cases: Complex ambiguity resolution, multi-step reasoningCost: Premium

o4-mini-2025-04-16

o4-mini

Display Name: o4-miniCompact reasoning model balancing quality and efficiency.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
⚠️ Streaming (limited)

Use Cases: Moderate complexity claims, budget-conscious reasoning tasksCost: Low

Anthropic Models

claude-sonnet-4-20250514

Claude Sonnet 4

Display Name: Claude Sonnet 4Anthropic’s balanced model with excellent claim understanding.Capabilities:

✅ Claim Normalization
⚠️ Structured Outputs (Pydantic only)
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: General fact-checking, nuanced content, production useCost: ModerateNote: Currently only supports Pydantic model structured outputs, not JSON schema

claude-opus-4-1-20250805

Claude Opus 4.1

Display Name: Claude Opus 4.1Anthropic’s most capable model with superior reasoning.Capabilities:

✅ Claim Normalization
❌ Structured Outputs (not yet supported)
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: High-quality claims, complex disambiguation, critical applicationsCost: Premium

Google Models

gemini-2.5-pro

Gemini 2.5 Pro

Display Name: Gemini 2.5 ProGoogle’s flagship model with strong factual grounding.Capabilities:

✅ Claim Normalization
✅ Structured Outputs (JSON Schema)
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: Fact verification, verifiability assessment, production workloadsCost: Moderate

gemini-2.5-flash

Gemini 2.5 Flash

Display Name: Gemini 2.5 FlashFast, efficient Gemini model optimized for speed.Capabilities:

✅ Claim Normalization
✅ Structured Outputs (JSON Schema)
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: High-volume processing, real-time applications, cost optimizationCost: Low

xAI Models (Grok)

grok-3

Grok 3

Display Name: Grok 3xAI’s base model with real-time knowledge integration.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: Current events, real-time claims, news fact-checkingCost: Moderate

grok-4-0709

Grok 4

Display Name: Grok 4xAI’s latest model with enhanced reasoning and real-time web access.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: Time-sensitive claims, breaking news, relevance assessmentCost: Moderate-Premium

grok-3-mini

Grok 3 Mini

Display Name: Grok 3 MiniCompact Grok model for efficient processing.Capabilities:

✅ Claim Normalization
✅ Structured Outputs
✅ Refinement
✅ Evaluation (G-Eval)
✅ Streaming

Use Cases: High-volume current events monitoring, cost-effective processingCost: Low

Together AI Models

meta-llama/Llama-3.3-70B-Instruct-Turbo-Free

Llama 3.3 70B

Display Name: Llama 3.3 70BMeta’s open-source flagship model with strong instruction following.Capabilities:

✅ Claim Normalization
✅ Structured Outputs (JSON Schema)
✅ Refinement
❌ Evaluation (not supported by DeepEval)
✅ Streaming

Use Cases: Open-source deployments, customization, researchCost: Free (via Together AI)

deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free

DeepSeek R1 Distill Llama 70B

Display Name: DeepSeek R1 Distill Llama 70BDeepSeek’s reasoning-enhanced Llama distillation.Capabilities:

✅ Claim Normalization
⚠️ Structured Outputs (limited)
✅ Refinement
❌ Evaluation (not supported by DeepEval)
✅ Streaming

Use Cases: Research, reasoning-heavy claims, cost-free experimentationCost: Free (via Together AI)

Model Comparison Table

Model	Provider	Quality	Speed	Cost	Best For
GPT-5	OpenAI	⭐⭐⭐⭐⭐	⚡⚡⚡⚡	$$$	Production, high-stakes
Claude Opus 4.1	Anthropic	⭐⭐⭐⭐⭐	⚡⚡⚡	$$$	Complex claims, quality
Claude Sonnet 4	Anthropic	⭐⭐⭐⭐	⚡⚡⚡⚡	$$	Balanced, production
Gemini 2.5 Pro	Google	⭐⭐⭐⭐	⚡⚡⚡⚡⚡	$$	Factual consistency
Gemini 2.5 Flash	Google	⭐⭐⭐	⚡⚡⚡⚡⚡	$	High volume, speed
Grok 4	xAI	⭐⭐⭐⭐	⚡⚡⚡⚡	$$	Current events
GPT-5 nano	OpenAI	⭐⭐⭐⭐	⚡⚡⚡⚡⚡	$$	Cost-effective quality
Llama 3.3 70B	Together AI	⭐⭐⭐	⚡⚡⚡⚡	Free	Open-source, research

API Configuration

Automatic Model Routing

CheckThat AI automatically routes requests to the correct provider:

From api/_utils/LLMRouter.py:14-43

class LLMRouter:
    def __init__(self, model: str, api_key: Optional[str] = None):
        self.model = model
        
        # Automatic provider detection
        if model in OPENAI_MODELS:
            self.api_provider = 'OPENAI'
        elif model in xAI_MODELS:
            self.api_provider = 'XAI'
        elif model in TOGETHER_MODELS:
            self.api_provider = 'TOGETHER'
        elif model in ANTHROPIC_MODELS:
            self.api_provider = 'ANTHROPIC'
        elif model in GEMINI_MODELS:
            self.api_provider = 'GEMINI'
        else:
            raise ValueError(f"Unsupported model: {model}")
        
        self.api_key = api_key
    
    def getAPIClient(self):
        """Returns appropriate API client for the model."""
        if self.api_provider == 'OPENAI':
            return OpenAIModel(model=self.model, api_key=self.api_key)
        elif self.api_provider == 'XAI':
            return xAIModel(model=self.model, api_key=self.api_key)
        elif self.api_provider == 'TOGETHER':
            return TogetherModel(model=self.model, api_key=self.api_key)
        elif self.api_provider == 'ANTHROPIC':
            return AnthropicModel(model=self.model, api_key=self.api_key)
        elif self.api_provider == 'GEMINI':
            return GeminiModel(model=self.model, api_key=self.api_key)

Model Constants

From api/_types.py:4-17

# OpenAI Models
OPENAI_MODELS = [
    "gpt-5-2025-08-07", "gpt-5-nano-2025-08-07", 
    "o3-2025-04-16", "o4-mini-2025-04-16"
]

# xAI Models
xAI_MODELS = ["grok-3", "grok-4-0709", "grok-3-mini"]

# Together AI Models
TOGETHER_MODELS = [
    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
    "deepseek-ai/DeepSeek-R1-Distill-Llama-70B-free"
]

# Anthropic Models
ANTHROPIC_MODELS = ["claude-sonnet-4-20250514", "claude-opus-4-1-20250805"]

# Google Models
GEMINI_MODELS = ["gemini-2.5-pro", "gemini-2.5-flash"]

Using Different Models

import openai

client = openai.OpenAI(
    base_url="https://api.checkthat.ai/v1",
    api_key="your-checkthat-api-key"
)

# Use GPT-5
response = client.chat.completions.create(
    model="gpt-5-2025-08-07",
    messages=[{"role": "user", "content": "Your claim..."}]
)

# Use Claude Sonnet 4
response = client.chat.completions.create(
    model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "Your claim..."}]
)

# Use Gemini Flash (fast & cheap)
response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "Your claim..."}]
)

# Use Llama (free via Together AI)
response = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
    messages=[{"role": "user", "content": "Your claim..."}]
)

Structured Output Support

Models with structured output support can return JSON according to a schema:

From api/_types.py:42-55

STRUCTURED_OUTPUT_SUPPORTED_MODELS = [
    # OpenAI models
    "gpt-5-2025-08-07", "gpt-5-nano-2025-08-07", 
    "o3-2025-04-16", "o4-mini-2025-04-16",
    "gpt-4o-2024-08-06", "gpt-4o-mini-2024-07-18",
    
    # Gemini models
    "gemini-2.5-pro", "gemini-2.5-flash",
    
    # xAI models
    "grok-3", "grok-4-0709", "grok-3-mini",
    
    # Together AI models (some support)
    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
    
    # Anthropic models (Pydantic only)
    "claude-sonnet-4-20250514"
]

Anthropic Limitation: Claude models currently only support Pydantic model structured outputs, not JSON schema. Use other providers for full JSON schema support.

Provider-Specific Features

OpenAI

From api/_utils/openai.py:18-29

class OpenAIModel:
    def __init__(self, model: str, api_key: str = None):
        self.model = model
        self.api_key = api_key
        self.client = OpenAI(api_key=self.api_key)

Features:

Native structured outputs via response_format
Streaming support
Function calling
JSON mode
Vision capabilities (GPT-4o, GPT-5)

Anthropic

From api/_utils/anthropic.py:21-32

class AnthropicModel:
    def __init__(self, model: str, api_key: str = None):
        self.model = model
        self.api_key = api_key
        self.client = anthropic.Anthropic(api_key=self.api_key)

Features:

Streaming support
System message separation
Instructor integration for Pydantic models
OpenAI-compatible response formatting

Google (Gemini)

From api/_utils/gemini.py:19-33

class GeminiModel:
    def __init__(self, model: str, api_key: str = None):
        if not api_key:
            raise ValueError("Gemini API key is required")
        self.model = model
        self.api_key = api_key
        self.client = genai.Client(api_key=self.api_key)

Features:

Native JSON schema support
System instructions
Streaming support
Safety ratings
Multimodal capabilities

xAI (Grok)

From api/_utils/xai.py:20-32

class xAIModel:
    def __init__(self, model: str, api_key: str = None):
        self.model = model
        self.api_key = api_key
        self.client = OpenAI(
            api_key=self.api_key, 
            base_url="https://api.x.ai/v1"
        )

Features:

OpenAI-compatible API
Real-time web access
Streaming support
JSON schema support

Together AI

From api/_utils/togetherAI.py:19-30

class TogetherModel:
    def __init__(self, model: str, api_key: str = None):
        self.model = model
        self.api_key = api_key
        self.client = Together(api_key=self.api_key)

Features:

Free tier for Llama and DeepSeek models
OpenAI-compatible responses
JSON schema support
Streaming support

Model Selection Guide

By Use Case
By Budget
By Latency

Production Fact-Checking

Primary: Claude Sonnet 4, GPT-5 nano
Backup: Gemini 2.5 Pro

High-Stakes Claims

Primary: GPT-5, Claude Opus 4.1
Backup: Gemini 2.5 Pro

High-Volume Processing

Primary: Gemini 2.5 Flash
Backup: GPT-5 nano, Grok 3 Mini

Current Events

Primary: Grok 4
Backup: Grok 3, GPT-5

Cost-Sensitive

Primary: Llama 3.3 70B (free)
Backup: Gemini 2.5 Flash, GPT-5 nano

Research & Development

Primary: DeepSeek R1, Llama 3.3 70B
Backup: o3, Claude Opus 4.1

Best Practices

Start with Balanced Models

Begin with Claude Sonnet 4 or GPT-5 nano for the best balance of quality, speed, and cost.

Test Multiple Models

Run A/B tests with 2-3 models to find the best fit for your specific use case.

Use Faster Models for Refinement

If using refinement, consider faster models (Gemini Flash, GPT-5 nano) to reduce latency.

Reserve Premium Models for Hard Cases

Use GPT-5 or Claude Opus only for complex claims that require maximum quality.

Monitor Model Performance

Track evaluation scores by model to identify which models work best for your content.

Next Steps

Claim Normalization

Learn how models normalize claims from social media posts

Refinement Pipeline

See how models iteratively improve claim quality

Evaluation Metrics

Understand how models evaluate claim quality

API Reference

Start using models via the CheckThat AI API

Get Started

Core Concepts

Web Application

Guides

Deployment

Overview

Supported Providers

OpenAI

Anthropic

Google

xAI

Meta (via Together AI)

DeepSeek (via Together AI)

Complete Model List

OpenAI Models

Anthropic Models

Google Models

xAI Models (Grok)

Together AI Models

Model Comparison Table

API Configuration

Automatic Model Routing

Model Constants

Using Different Models

Structured Output Support

Provider-Specific Features

OpenAI

Anthropic

Google (Gemini)

xAI (Grok)

Together AI

Model Selection Guide

Best Practices

Next Steps

Claim Normalization

Refinement Pipeline

Evaluation Metrics

API Reference

Build docs developers (and LLMs) love

Get Started

Core Concepts

Web Application

Guides

Deployment

​Overview

​Supported Providers

OpenAI

Anthropic

Google

xAI

Meta (via Together AI)

DeepSeek (via Together AI)

​Complete Model List

​OpenAI Models

​Anthropic Models

​Google Models

​xAI Models (Grok)

​Together AI Models

​Model Comparison Table

​API Configuration

​Automatic Model Routing

​Model Constants

​Using Different Models

​Structured Output Support

​Provider-Specific Features

​OpenAI

​Anthropic

​Google (Gemini)

​xAI (Grok)

​Together AI

​Model Selection Guide

​Best Practices

​Next Steps

Claim Normalization

Refinement Pipeline

Evaluation Metrics

API Reference

Build docs developers (and LLMs) love

Overview

Supported Providers

Complete Model List

OpenAI Models

Anthropic Models

Google Models

xAI Models (Grok)

Together AI Models

Model Comparison Table

API Configuration

Automatic Model Routing

Model Constants

Using Different Models

Structured Output Support

Provider-Specific Features

OpenAI

Anthropic

Google (Gemini)

xAI (Grok)

Together AI

Model Selection Guide

Best Practices

Next Steps