Quick Start

Get started with GPUPulse API in under 5 minutes. Save 20-40% on compute costs instantly.

Find Cheapest GPU Cluster

Single API call to compare prices across 15+ providers and find the best deal

# Find cheapest H100 cluster for your needs
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.gpupulse.com/v1/realtime/h100?quantity=8"

# Response: 8x H100 cluster for $48.80/hr vs $68/hr average
# Monthly savings: $13,824

Essential Info

Base URL:https://api.gpupulse.com/v1

Auth Header:Authorization: Bearer YOUR_API_KEY

Authentication

All API requests require a Bearer token in the Authorization header.

Get API Key

curl -H "Authorization: Bearer gp_1234567890abcdef" \
  "https://api.gpupulse.com/v1/realtime/h100"

API Endpoints

GET /realtime/{gpu_type}

Real-Time Pricing

Use Case: Find providers with GPUs in stock right now

When to call: Before training jobs, scaling inference, or planning procurement

Parameters: quantity (1-100), region (us-east, us-west, eu-west)

GET /v1/realtime/h100?quantity=8

{
  "gpu_type": "h100",
  "quantity_requested": 8,
  "updated_at": "2025-01-09T15:30:00Z",
  "market_overview": {
    "cheapest_total_cost": 48.80,
    "average_total_cost": 68.00,
    "total_savings": 19.20,
    "monthly_savings": 13824
  },
  "available_providers": [
    {
      "name": "Lambda Labs",
      "price_per_hour": 6.10,
      "total_cost": 48.80,
      "available_gpus": 12,
      "can_fulfill": true,
      "allocation_time": "< 2 minutes",
      "region": "us-east"
    }
  ]
}

POST /webhooks

Price Alerts

Use Case: Get notified when GPUs hit your target price

When to call: Set up automated notifications for cost-saving opportunities

Business Value: Automated procurement at optimal prices

POST /v1/webhooks
{
  "gpu_type": "h100",
  "quantity": 8,
  "trigger_condition": "price_below",
  "target_price_total": 50.00,
  "webhook_url": "https://your-app.com/gpu-alert",
  "notification_name": "H100 Cluster Budget Alert"
}

# Response
{
  "webhook_id": "wh_123",
  "status": "active", 
  "estimated_monthly_savings": "$11,520 if triggered daily"
}

GET /historical/{gpu_type}

Market Intelligence

Use Case: Understand pricing patterns to time GPU purchases

When to call: Plan procurement timing, understand market cycles

Parameters: days (7, 30, 90), quantity (for cluster pricing)

GET /v1/historical/h100?days=30&quantity=8

{
  "gpu_type": "h100",
  "quantity": 8,
  "period_days": 30,
  "current_total_cost": 48.80,
  "market_analysis": {
    "trend_direction": "decreasing",
    "price_change_percent": "-18.5%",
    "best_purchase_times": ["weekends", "month_end"]
  },
  "cost_predictions": {
    "next_7_days": {
      "predicted_low": 45.60,
      "predicted_high": 52.40,
      "recommendation": "wait_for_better_price"
    }
  },
  "procurement_insights": {
    "optimal_purchase_window": "next_3_days"
  }
}

Code Examples

Automated Cost Optimization

Find available GPU clusters within budget and automatically provision the cheapest option

def find_gpu_cluster(gpu_type, quantity, max_cost_per_hour):
    response = requests.get(
        f"https://api.gpupulse.com/v1/realtime/{gpu_type}",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        params={"quantity": quantity}
    )
    
    data = response.json()
    
    # Find providers that can fulfill request within budget
    options = []
    for provider in data["available_providers"]:
        if provider["can_fulfill"] and provider["total_cost"] <= max_cost_per_hour:
            options.append({
                "provider": provider["name"],
                "total_cost": provider["total_cost"],
                "monthly_savings": data["market_overview"]["monthly_savings"]
            })
    
    return sorted(options, key=lambda x: x["total_cost"])

# Example: Need 8x H100, budget $60/hour total
clusters = find_gpu_cluster("h100", 8, 60.00)
print(f"Monthly savings: $" + str(clusters[0]['monthly_savings']))

Error Handling

Common Error Responses

Handle insufficient availability and get alternative options

{
  "error": "insufficient_availability",
  "message": "Only 3 H100s available, you requested 8",
  "suggestion": "Try smaller quantity or check back in 1-2 hours",
  "alternative_options": [
    {
      "gpu_type": "a100",
      "available_quantity": 16,
      "price_comparison": "20% cheaper per FLOP"
    }
  ]
}

Complete Integration Example

Production-Ready Python Class

Complete example demonstrating all core functionality with proper error handling

import requests

class GPUProcurement:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.gpupulse.com/v1"
        self.headers = {"Authorization": f"Bearer {api_key}"}
    
    def find_cluster(self, gpu_type, quantity, budget_per_hour):
        """Find available GPU cluster within budget"""
        response = requests.get(
            f"{self.base_url}/realtime/{gpu_type}",
            headers=self.headers,
            params={"quantity": quantity}
        )
        
        data = response.json()
        
        # Filter by budget and availability
        options = [p for p in data["available_providers"] 
                  if p["can_fulfill"] and p["total_cost"] <= budget_per_hour]
        
        if options:
            best = min(options, key=lambda x: x["total_cost"])
            return {
                "provider": best["name"],
                "cost": best["total_cost"],
                "savings": budget_per_hour - best["total_cost"],
                "allocation_time": best["allocation_time"]
            }
        return None
    
    def check_market_timing(self, gpu_type, quantity):
        """Check if now is a good time to buy"""
        response = requests.get(
            f"{self.base_url}/historical/{gpu_type}",
            headers=self.headers,
            params={"quantity": quantity, "days": 30}
        )
        
        data = response.json()
        return data["cost_predictions"]["next_7_days"]["recommendation"]
    
    def setup_budget_alert(self, gpu_type, quantity, max_budget):
        """Get notified when cluster becomes affordable"""
        requests.post(
            f"{self.base_url}/webhooks",
            headers=self.headers,
            json={
                "gpu_type": gpu_type,
                "quantity": quantity,
                "trigger_condition": "price_below",
                "target_price_total": max_budget,
                "webhook_url": "https://yourapp.com/webhook"
            }
        )

# Usage
procurement = GPUProcurement("your-api-key")

# Check current availability and pricing
cluster = procurement.find_cluster("h100", 8, 55.00)
if cluster:
    print(f"Available: {cluster['provider']} - $" + str(cluster['cost']) + "/hr")
    print(f"Savings: $" + str(cluster['savings']) + "/hr")
    
    # Check if timing is good
    timing = procurement.check_market_timing("h100", 8)
    print(f"Market timing: {timing}")
else:
    print("No clusters available within budget")
    
    # Set up alert for when price drops
    procurement.setup_budget_alert("h100", 8, 55.00)
    print("Alert set - you'll be notified when cluster becomes affordable")

Ready to Start Saving?

Get your API key and start optimizing compute costs in minutes

Get Free API Key View Pricing

50 free API requests • No credit card required

External Links

Quick Actions