X APIdocs.x.ai ↗

"""
xAI Pricing API Client
Retrieve pricing information for all xAI (Grok) models and services.
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Literal


class ParseClient:
    """Client for interacting with the xAI Pricing API via Parse."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse client.

        Args:
            api_key: Your Parse API key. Defaults to PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "aa5ce901-2eef-4452-97a6-2dd2d8cee956"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError("API key is required. Pass it or set PARSE_API_KEY env var.")

    def _call(self, endpoint: str, method: str = "POST", **params) -> dict:
        """
        Make an API call to the Parse bot.

        Args:
            endpoint: The endpoint name (e.g., 'get_pricing')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters

        Returns:
            Response JSON as dictionary
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}

        if method.upper() == "GET":
            response = requests.get(url, headers=headers, params=params)
        elif method.upper() == "POST":
            response = requests.post(url, headers=headers, json=params)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")

        response.raise_for_status()
        return response.json()

    def get_pricing(self) -> dict:
        """
        Get all xAI model and service pricing information.

        Returns pricing for Chat API, Imagine API (image/video), Voice API,
        Tools, Batch API comparisons, and storage costs. All prices in USD.

        Returns:
            Dictionary containing all pricing categories
        """
        return self._call("get_pricing", method="GET")

    def get_model_pricing(
        self, category: Literal["all", "chat", "imagine", "voice", "tools", "batch", "storage"] = "all"
    ) -> dict:
        """
        Get xAI pricing filtered by service category.

        Args:
            category: Pricing category to retrieve. Defaults to 'all'.
                     Options: all, chat, imagine, voice, tools, batch, storage

        Returns:
            Dictionary containing pricing for the specified category
        """
        return self._call("get_model_pricing", method="GET", category=category)


def format_price(price_str: str) -> str:
    """Format price string for display."""
    return price_str.replace("$", "").strip()


def find_cheapest_chat_model(pricing_data: dict) -> Optional[dict]:
    """Find the cheapest chat model based on input token pricing."""
    if not pricing_data.get("chat_api"):
        return None

    chat_models = pricing_data["chat_api"]
    return min(chat_models, key=lambda m: float(format_price(m["input_per_1m_tokens"])))


def find_most_expensive_chat_model(pricing_data: dict) -> Optional[dict]:
    """Find the most expensive chat model based on input token pricing."""
    if not pricing_data.get("chat_api"):
        return None

    chat_models = pricing_data["chat_api"]
    return max(chat_models, key=lambda m: float(format_price(m["input_per_1m_tokens"])))


def calculate_monthly_cost(tokens: int, model_pricing: dict, cached_ratio: float = 0.0) -> float:
    """
    Calculate estimated monthly cost for token usage.

    Args:
        tokens: Number of tokens to process per month
        model_pricing: Model pricing dict from chat_api
        cached_ratio: Ratio of cached tokens (0.0 to 1.0)

    Returns:
        Estimated monthly cost in USD
    """
    input_price = float(format_price(model_pricing["input_per_1m_tokens"]))
    cached_price = float(format_price(model_pricing["cached_input_per_1m_tokens"]))

    regular_tokens = tokens * (1 - cached_ratio)
    cached_tokens = tokens * cached_ratio

    cost = (regular_tokens * input_price + cached_tokens * cached_price) / 1_000_000
    return cost


if __name__ == "__main__":
    # Initialize the client
    client = ParseClient()

    print("=" * 70)
    print("xAI PRICING ANALYSIS")
    print("=" * 70)

    # Get all pricing data
    print("\n📊 Fetching complete pricing information...")
    all_pricing = client.get_pricing()

    # Analyze chat models
    print("\n💬 CHAT API MODELS:")
    print("-" * 70)
    if "chat_api" in all_pricing:
        for model in all_pricing["chat_api"]:
            print(f"\n  Model: {model['model']}")
            print(f"    Context Window: {model['context']}")
            print(f"    Input Cost: {model['input_per_1m_tokens']} per 1M tokens")
            print(f"    Cached Input: {model['cached_input_per_1m_tokens']} per 1M tokens")
            print(f"    Output Cost: {model['output_per_1m_tokens']} per 1M tokens")

    # Find cost-effective models
    print("\n" + "=" * 70)
    print("💰 COST ANALYSIS:")
    print("-" * 70)

    cheapest = find_cheapest_chat_model(all_pricing)
    if cheapest:
        print(f"\n✅ Cheapest Model: {cheapest['model']}")
        print(f"   Input Cost: {cheapest['input_per_1m_tokens']}")

    most_expensive = find_most_expensive_chat_model(all_pricing)
    if most_expensive:
        print(f"\n⚠️  Most Expensive Model: {most_expensive['model']}")
        print(f"   Input Cost: {most_expensive['input_per_1m_tokens']}")

    # Calculate monthly costs for different scenarios
    print("\n📈 MONTHLY COST PROJECTIONS (100M tokens/month):")
    print("-" * 70)
    if "chat_api" in all_pricing:
        monthly_tokens = 100_000_000
        for model in all_pricing["chat_api"][:2]:  # Show top 2 models
            cost_no_cache = calculate_monthly_cost(monthly_tokens, model, cached_ratio=0.0)
            cost_with_cache = calculate_monthly_cost(monthly_tokens, model, cached_ratio=0.3)
            print(f"\n  {model['model']}:")
            print(f"    Without caching: ${cost_no_cache:,.2f}")
            print(f"    With 30% caching: ${cost_with_cache:,.2f}")
            print(f"    Monthly savings: ${cost_no_cache - cost_with_cache:,.2f}")

    # Get specific category pricing
    print("\n" + "=" * 70)
    print("🎨 IMAGE GENERATION (IMAGINE API):")
    print("-" * 70)
    imagine_pricing = client.get_model_pricing(category="imagine")
    if "imagine_api" in imagine_pricing:
        for model in imagine_pricing["imagine_api"]:
            print(f"\n  Model: {model['model']}")
            print(f"  Media Input: {model['media_input']}")
            print(f"  Output Pricing:")
            for res in model["resolutions"]:
                print(f"    {res['resolution']}: {res['output']}")

    # Check voice pricing
    print("\n" + "=" * 70)
    print("🎤 VOICE API:")
    print("-" * 70)
    voice_pricing = client.get_model_pricing(category="voice")
    if "voice_api" in voice_pricing:
        for voice in voice_pricing["voice_api"]:
            print(f"\n  Mode: {voice['mode']}")
            print(f"  Cost: {voice['cost']}")

    # Check tools pricing
    print("\n" + "=" * 70)
    print("🔧 TOOLS PRICING:")
    print("-" * 70)
    tools_pricing = client.get_model_pricing(category="tools")
    if "tools_pricing" in tools_pricing:
        for tool in tools_pricing["tools_pricing"]:
            print(f"\n  Tool: {tool['tool']} ({tool['tool_name']})")
            print(f"    {tool['description']}")
            print(f"    Cost: {tool['cost_per_1k_calls']}")

    # Check storage pricing
    print("\n" + "=" * 70)
    print("💾 STORAGE & FILES:")
    print("-" * 70)
    storage_pricing = client.get_model_pricing(category="storage")
    if "files_and_collections" in storage_pricing:
        fc = storage_pricing["files_and_collections"]
        if "storage" in fc:
            print("\n  Storage Rates:")
            for item in fc["storage"]:
                print(f"    {item['resource']}: {item['rate']}")
        if "downloads" in fc:
            print("\n  Download Rates:")
            for item in fc["downloads"]:
                print(f"    {item['resource']}: {item['rate']}")

    print("\n" + "=" * 70)
    print("✅ Pricing analysis complete!")
    print("=" * 70)