Artificial Analysis APIartificialanalysis.ai ↗
Access AI model benchmarks, provider leaderboards, hardware GPU data, and cost-per-task metrics from Artificial Analysis via 9 structured endpoints.
What is the Artificial Analysis API?
The Artificial Analysis API exposes 9 endpoints covering LLM provider leaderboards, per-model benchmark scores, GPU hardware benchmarks, and cost-per-task metrics. The get_llm_providers_leaderboard endpoint alone returns a full dataset of provider-model combinations with pricing, latency, throughput, and benchmark scores across every tracked host. Additional endpoints cover image, video, and speech model families, making it practical to build model-selection tools, cost calculators, and performance dashboards without maintaining your own benchmark pipeline.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/ae371dc0-d495-4644-ae2f-97fbf3214b85/get_llm_providers_leaderboard' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace artificialanalysis-ai-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Artificial Analysis SDK — compare AI model costs, providers, and hardware."""
from parse_apis.Artificial_Analysis_API import (
ArtificialAnalysis, Query, ModelNotFound
)
client = ArtificialAnalysis()
# Browse cost-per-task data filtered to specific models.
for task in client.cost_per_tasks.list(models="claude-sonnet-5,gpt-5-6-sol", limit=3):
print(task.name, task.cost_per_task, task.intelligence_index, task.ttft)
if task.cost_per_task_breakdown:
print(" breakdown:", task.cost_per_task_breakdown.input_tokens, task.cost_per_task_breakdown.reasoning_tokens)
# Get cost-per-task detail for a single model by slug.
detail = client.cost_per_tasks.get(slug="gpt-5-6-sol")
print(detail.name, detail.cost_per_task, detail.coding_index, detail.coding_cost_per_task)
# Search for GPT models and print their summaries.
for model in client.models.search(query=Query.GPT, limit=3):
print(model.name, model.slug, model.is_reasoning)
# Drill into a specific model's providers via the constructible shortcut.
for provider in client.model("claude-sonnet-4").providers.list(limit=3):
print(provider.slug, provider.json_mode, provider.function_calling)
# Browse the LLM providers leaderboard.
for endpoint in client.provider_endpoints.list(limit=3):
print(endpoint.label, endpoint.host_api_id)
# Typed error handling: attempt to fetch a model that does not exist.
try:
client.models.get(slug="nonexistent-model-xyz")
except ModelNotFound as exc:
print(f"Model not found: {exc.slug}")
print("exercised: cost_per_tasks.list / cost_per_tasks.get / models.search / model().providers.list / provider_endpoints.list / models.get")
Get the main LLM API Providers Leaderboard data, including all model endpoints and their performance metrics (speed, latency, price, etc.). Returns a large dataset of provider-model combinations with pricing, timescale performance data, and benchmark scores.
No input parameters required.
{
"type": "object",
"fields": {
"endpoints": "array of provider-model endpoint objects with pricing, performance metrics, host info, model benchmarks, and timescale data"
}
}About the Artificial Analysis API
LLM Provider and Model Data
The get_llm_providers_leaderboard endpoint returns an array of provider-model endpoint objects that include input/output token pricing, timescale performance data, and host metadata — no parameters required. For a focused lookup, get_model_providers accepts a slug string (e.g., gpt-4o, claude-sonnet-4) and returns the full model detail object alongside a providers array with fields like price_1m_input_tokens, price_1m_output_tokens, cache pricing, and feature flags such as JSON mode and function calling support.
Model Benchmarks and Intelligence Scores
get_model_detail returns per-model fields including intelligence_index, context_window_token, benchmark scores, and evaluation data for a given slug. get_models_list provides a flat index of all tracked models with id, slug, name, shortName, deprecated, isReasoning, and creator info — useful for enumerating the full model catalog before drilling into specifics. search_models filters that same list against a query string matched case-insensitively against name, slug, and short name fields.
Cost-Per-Task and Multimodal Model Families
get_cost_per_task returns per-model arrays with cost_per_task (USD), intelligence_index, time_per_task, TTFT, end_to_end_response_time, and token counts broken down into input, output, and reasoning tokens. An optional models parameter accepts comma-separated slugs to filter the response. get_model_cost_per_task retrieves the same shape for a single model by slug. For non-LLM modalities, get_speech_image_video_models returns separate arrays for image generation, video generation, speech-to-text, and text-to-speech model families with name, slug, URL, and creator.
Hardware Benchmarks
get_hardware_benchmarks returns a chips array of GPU objects with memory bandwidth, capacity, power, and creator info, alongside a system_benchmarks array with throughput, output speed, latency measurements, inference framework details, and nested model and chip references. This data is useful for comparing inference hardware independently from the hosted API providers in the LLM leaderboard.
The Artificial Analysis API is a managed, monitored endpoint for artificialanalysis.ai — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when artificialanalysis.ai changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official artificialanalysis.ai API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a model selection tool that ranks providers by output token price and latency using
get_llm_providers_leaderboarddata. - Track intelligence index trends across model versions by querying
get_model_detailfor successive slugs. - Calculate per-query cost estimates using
cost_per_task, input/output token counts, and pricing fields fromget_model_providers. - Identify which providers support function calling or JSON mode for a specific model using feature flags in the providers array.
- Compare GPU inference hardware by throughput and memory bandwidth using
get_hardware_benchmarkschip and system benchmark data. - Filter the model catalog for reasoning-capable models using the
isReasoningflag fromget_models_list. - Populate a multimodal model directory covering image, video, and speech families using
get_speech_image_video_models.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Artificial Analysis have an official developer API?+
What does `get_cost_per_task` return and how can I filter it?+
get_cost_per_task returns an array of model objects each containing cost_per_task in USD, a granular cost breakdown, intelligence_index, time_per_task, TTFT, end_to_end_response_time, and per-task token counts split into input, output, and reasoning tokens, plus a coding_index score. Pass a comma-separated list of model slugs to the optional models parameter to limit results to specific models.Does the API include historical benchmark time-series data?+
get_llm_providers_leaderboard and get_model_providers responses include timescale arrays reflecting recent performance snapshots. You can fork this API on Parse and revise it to add a dedicated historical trends endpoint if that granularity is needed.Does the API cover fine-tuned or private model deployments listed on Artificial Analysis?+
How does `search_models` match queries, and what does it return?+
search_models performs a case-insensitive substring match against the name, slug, and shortName fields of every model in the catalog. It returns a results array of matching model summary objects with the same shape as get_models_list: id, slug, name, shortName, deprecated, isReasoning, and creator info. It does not search benchmark scores or provider data.