The APIs AI agents reach for most, and how usable each one actually is from its OpenAPI spec, scored with the open Jentic API AI-Readiness Framework.
A valid OpenAPI spec doesn't mean an agent can use it. Most specs were written for human developers reading docs, not for an agent reasoning about operations on its own. This list is a collection of the APIs agents need most, split into the ones a spec can carry today and the essential ones whose specs still make an agent work harder. Every entry links straight to the standardised spec in the Jentic API Directory.
The obvious objection: if an API matters, someone builds an MCP for it, so who cares about the raw spec?
Three reasons. MCPs cover dozens of APIs; there are 100,000+ in the wild. Your agent will hit ones that have none. An MCP exposes a hand-picked slice: 15–30 tools out of hundreds of endpoints, and the rest lives only in the spec. And coding agents read specs directly: when Claude Code or Cursor writes an integration, it's interpreting the OpenAPI document, not calling an MCP.
Then the case that settles it: your own internal APIs will never get an MCP. A team with 50 internal services has 50 specs and no shortcuts. Stripe can afford to build an MCP to make up for a hard-to-parse spec. You can't do that for every service your team maintains, so the spec has to carry the agent on its own.
We report two dimensions from the JAIRF framework: the two that answer "can an agent use this API from its spec?" Both are scored 0-100. We don't combine them into one number; we show both, because they tell different stories.
| Signal | What it measures |
|---|---|
| Agent Usability | How much structural complexity an agent has to handle: endpoint count and schema depth. Small, focused APIs with shallow schemas score highest. |
| AI-Readiness | Can an agent understand what the API does? Description coverage, semantic richness, operation-ID quality, summary clarity. |
A note on the numbers: Agent Usability peaks at 93.7. That is the ceiling for an API with no meaningful structural complexity (roughly under 50 operations, shallow schemas), and many well-designed, focused APIs earn exactly that ceiling, which is why you will see it repeatedly in the Agent-ready tier. AI-Readiness varies more between APIs, so it is usually the differentiator.
The framework's other four dimensions (Security, Compliance, Developer Experience, Discoverability) matter for governance and tooling, but they don't tell you whether an agent can read and operate the API. That's what these two do.
How an API gets on this list:
- Agent-ready: scores strongly on at least one signal, with the other in usable range.
- Essential, harder for agents: widely needed by agents regardless of score, shown with honest numbers so you know where the friction is. This is where a standardised, agent-ready spec earns its keep.
APIs whose specs an agent can read and operate today. Names link to the standardised spec in the Jentic API Directory.
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Anthropic API | Generate text and run tool-use loops with Claude models; batch and stream messages | 93.5 | 48.3 |
| Groq API | Run low-latency LLM inference: chat completions and audio transcription | 93.7 | 49.5 |
| Amazon Bedrock Runtime | Invoke and stream foundation models with guardrails and multi-turn conversation | 93.7 | 47.7 |
| OpenAI API | Chat, audio, embeddings, assistants, and image generation across OpenAI models | 76.5 | 48.2 |
| Cohere API | Generate text, create embeddings, and rerank results for search and RAG | 93.7 | 30.8 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Algolia Insights | Send click, conversion, and view events to train relevance and personalization | 93.7 | 62.3 |
| Algolia Recommend | Return related-item and frequently-bought-together recommendations | 93.7 | 57.5 |
| Algolia Ingestion | Connect sources and schedule data imports into Algolia indexes | 92.3 | 56.4 |
| Algolia Search | Query indexes for ranked, typo-tolerant results with faceting and filtering | 89.5 | 54.0 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| ClickUp API | Create and update tasks, lists, and docs; track time and manage workspaces | 93.7 | 55.7 |
| Figma REST API | Read file contents, export images, and pull comments and component metadata | 93.7 | 50.2 |
| Linear API | Create and update issues, projects, and cycles; query teams and states | 93.7 | 45.3 |
| Airtable Web API | Read and write records, fields, and tables across bases | 93.7 | 43.1 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| AWS Lambda | Create, invoke, and manage serverless functions and their event triggers | 93.7 | 54.7 |
| Docker Engine API | Build, run, and manage containers, images, networks, and volumes | 83.2 | 48.4 |
| AWS Step Functions | Orchestrate multi-step workflows as state machines across AWS services | 93.7 | 37.0 |
| Amazon EKS | Provision and manage Kubernetes clusters, node groups, and add-ons | 93.7 | 38.9 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Supabase Management API | Provision and configure Supabase projects, databases, and auth settings | 93.7 | 54.6 |
| Neon API | Provision serverless Postgres projects, branches, and database endpoints | 71.9 | 53.3 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| SendGrid Mail API | Send transactional and marketing email and track delivery events | 93.7 | 41.4 |
| Resend | Send transactional email and manage domains, audiences, and broadcasts | 91.0 | 31.6 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Sentry API | Query issues and events, manage projects, and track release health | 93.7 | 59.1 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Auth0 Authentication API | Authenticate users, exchange tokens, and run OAuth and passwordless flows | 93.7 | 48.9 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Contentful Images API | Transform, resize, and reformat images served from Contentful | 93.7 | 48.7 |
| Dropbox API v2 | Upload, download, share, and manage files and folders | 89.5 | 46.9 |
| API | What your agent can do with it | Agent Usability | AI-Readiness |
|---|---|---|---|
| Spotify Web API | Search tracks, manage playlists, and read playback and library data | 87.2 | 54.4 |
These are APIs agents reach for constantly, and their specs score low on one or both signals. They're not bad APIs; they're large, mature, and specced for human developers, not for an agent reading them cold. Your agent will need them anyway. The score tells you where the friction is, and it's exactly here that a standardised, agent-ready spec (and an execution layer that handles the spec for you) does the most work.
| API | What your agent needs it for | Agent Usability | AI-Readiness | Why it's hard |
|---|---|---|---|---|
| Stripe API | Process payments, manage subscriptions and invoices, issue refunds | 42.6 | 48.9 | 600+ endpoints, a huge surface to reason over |
| GitHub REST API | Manage repos, issues, pull requests, actions, and releases | 42.6 | 18.2 | 900+ endpoints, minimal descriptions |
| Slack Web API | Post messages, manage channels, respond to events | 57.9 | 27.5 | Sparse descriptions, low semantic clarity |
| Notion API | Create and query pages, databases, and blocks | 21.1 | 51.3 | Complex nested-object model |
| Shopify Admin API | Manage products, orders, customers, and inventory | 42.6 | 51.8 | Large surface, limited per-operation context |
| Gmail API | Read, send, and organize email; manage labels and threads | 89.3 | 6.7 | Operable, but almost no semantic description |
| Twilio Messaging | Send and receive SMS, MMS, and WhatsApp messages | 92.8 | 37.7 | Strong usability, thin descriptions |
| Intercom API | Manage conversations, contacts, and help articles | 73.9 | 47.1 | Borderline, close to the top tier |
Every API here is in the Jentic API Directory. To give your agent access to any of them without hardcoding credentials or writing glue code, use Jentic Mini, a self-hosted execution layer that sits between your agent and the API.
docker run -d --name jentic-mini -p 8900:8900 -v jentic-mini-data:/app/data jentic/jentic-miniYour agent says what it wants to do. Jentic Mini handles the how: finding the right operation, injecting credentials at runtime, brokering the request. Secrets never touch the agent.
- 7,400+ APIs from the directory, available once you add credentials
- Credential vault: keys and OAuth tokens stored encrypted, injected at execution time
- Toolkits: scoped, individually revocable access per agent
- No glue code: your agent searches by intent, and Jentic Mini executes
This is the answer to the "Essential, but harder for agents" tier above: the hard specs are hard for the agent. Jentic Mini reads them so your agent doesn't have to.
The scores here come from an open framework you can run on any spec, including your private internal ones.
Online: upload an OpenAPI spec at jentic.com/scorecard for an assessment across all six JAIRF dimensions.
CLI (local, nothing sent to Jentic):
npx @jentic/api-scorecard-cli@latest score <path-or-url-to-openapi-spec>Learn more:
Maintained by Jentic, sourced from the Jentic API Directory, 7,400+ APIs scored for AI-agent readiness. Scores are generated by the Jentic API Scorecard using the JAIRF specification. We report Agent Usability and AI-Readiness because they measure whether an agent can read and operate an API from its spec.
See CONTRIBUTING.md for how to suggest an API or flag a score.
Content licensed under CC BY 4.0: use it, share it, build on it, with attribution.
© 2026 Jentic.