API Design Report Card
Consistency, pagination, errors, versioning. A bad API wastes your time.
Industry benchmark. Consistent naming, idempotency keys, expandable objects, excellent error messages.
REST v3 and GraphQL v4. Both well-documented. Pagination via Link headers.
Clean REST API. Batch operations. Good error messages. Fast responses.
Minimal and clean. Few endpoints, all consistent. Svix webhooks.
GraphQL-only done right. Cursor pagination, consistent types, real-time webhooks. Developer-first API.
Clean OpenAI-compatible structure. Streaming is first-class. Rate limit headers on every response.
De-facto standard for AI APIs. Streaming, function calling, and batch endpoints well-designed.
Query/mutation/action model is consistent and elegant. Pagination via cursors built into the SDK. Type-safe from client to server.
Not an API provider but a framework for building them. RPC mode gives typed client generation from server routes. Middleware pattern is consistent.
Stripe-inspired REST API. Consistent resource naming, idempotency support, structured errors with request_id. Webhook signatures via HMAC.
Clean RESTful design. Every error has code, type, message, and link to docs. Consistent JSON responses across all endpoints.
Stripe-quality REST API. Consistent naming, cursor pagination, structured errors with codes. Svix webhooks. Built for enterprise integrations.
Clean JSON API. Error codes are well-documented with specific numbers and descriptions. Webhooks are reliable with retry logic.
Redis commands over HTTP. Brilliant simplicity — each command is a URL path. Rate limit and usage headers on every response.
Clean REST API for auth flows. Error responses include error_type, error_message, and status_code consistently. Request IDs on every response.
Auto-generated REST and GraphQL from schema. FILTER, SORT, FIELDS params are consistent across all collections. Well-structured error responses.
Binary protocol for performance, HTTP for convenience. Auto-generated GraphQL from schema. Consistent error formatting with hints and details.
S3-compatible API — use any S3 client. ListObjectsV2 pagination is standard. Bucket notifications for webhooks. Admin API is separate and well-designed.
REST v4 and GraphQL APIs are comprehensive. Keyset pagination on most endpoints. Consistent error envelope. Rate limit headers on every response.
JSON API for dynamic config is beautifully designed. CRUD on config paths via URL. Consistent error responses. Config traversal via path segments is elegant.
Stripe-inspired REST API. Consistent resource naming for products, subscriptions, and orders. Cursor pagination. Svix webhooks with signature verification.
Clean REST API with OpenAPI spec. Errors include code, message, and doc_url. Cursor pagination on analytics. Webhook events for link interactions.
Workflows API is consistent — trigger, schedule, cancel. Channel and tenant resources follow CRUD patterns. Outbound webhooks for delivery events.
OpenAI-compatible chat completions API. Streaming via SSE. Rate limit headers per model. Error responses match OpenAI format exactly.
Predictions API is consistent — POST to start, GET to poll, or use webhook. Streaming via SSE. Cursor pagination on listings.
Self-hosted — endpoints follow predictable /api/auth/* pattern. Errors return APIError with code and status. Plugin system extends API consistently.
GraphQL-first with consistent input/output types. Cursor pagination on connections. Errors include code and machine-readable type. Webhook signatures via HMAC.
Clean REST API for chat, embed, rerank, and classify endpoints. Streaming via SSE. Errors include code and message. Cursor pagination on list endpoints.
Clean REST API with OpenAPI spec. Datasets, queries, and ingest endpoints follow consistent patterns. APL query language passed as JSON body. Rate limit and usage headers on every ingest response. Webhook monitors are newer and occasionally miss edge cases.
OpenAI-compatible chat completions API. Streaming via SSE. Rate limit headers per model tier. Supports function calling and JSON mode. Error format matches OpenAI standard.
OpenAI-compatible API with clean extensions for tool use and JSON mode. Streaming via SSE. Batch endpoint for async processing. Rate limits documented per endpoint.
Clean REST API for API key management. Key verification endpoint is sub-50ms globally. Consistent error format with code and requestId. OpenAPI spec published.
Middleware-first API — decisions returned as structured JSON with reason codes. Rate limiting, bot detection, email validation in one consistent interface. gRPC backend, REST-facing SDK.
OpenAI-compatible chat completions API. Fastest inference — streaming barely needed at 2000+ tok/s. Rate limit headers per tier. Error format matches OpenAI standard exactly.
PostgREST-based. Powerful but unusual query syntax. No rate limit headers.
Clean REST API. Good error messages with codes. Svix-powered webhooks.
Decent REST API. Some endpoints undocumented. Deploy hooks are reliable.
Cursor-based pagination done right. Some legacy endpoints still around.
Functional API. HogQL adds query power. Some inconsistencies between endpoints.
v4 API is vast. Consistency varies across 50+ products. Good rate limit docs.
Form-encoded POST bodies feel dated in 2024. Error codes are documented. Webhooks are rock-solid.
Management API is clean for branch/project operations. Database access is standard Postgres wire protocol.
GraphQL API exposes full platform. Schema is consistent but introspection docs are sparse.
V2 API is more consistent than V1 but both are live simultaneously. 400+ endpoints across many products.
Event-driven API is clean. REST for management, HTTP callbacks for functions. Webhook reliability is a core product feature.
v3 API is well-structured. Task triggering and run inspection endpoints are consistent. Callback-based execution model.
Platform API for managing databases and groups is clean. Data access is via libSQL protocol, not REST. Token management API is straightforward.
Tiny API surface — upload routes and file management. Framework adapters (Next.js, SvelteKit) handle most complexity. Simple and focused.
RESTful API with consistent CRUD patterns. Batch import endpoints well-designed. Error messages include field-level detail.
Multiple APIs (Geocoding, Directions, Tiles) with varying conventions. Older APIs feel different from newer ones. Rate limits well-documented.
Upload and Admin APIs are separate with different conventions. URL-based transformation API is unique and powerful. Webhook notifications for async operations.
REST API covers all platform features. PATCH-based flag updates use JSON Patch standard. Rate limits are generous.
Tracking API is elegant and simple. Config API for managing sources/destinations is separate and more complex. Batch endpoint well-designed.
Clean management API. Deployment and project endpoints are consistent. KV and Cron APIs follow web standards. Growing coverage.
Automation API is well-structured. Stack and deployment management endpoints are consistent. Cloud service REST API is secondary to SDK usage.
Management API for branches and deploy requests is clean. Database access is MySQL wire protocol. Branch management endpoints are well-designed.
REST API auto-generated from schema. Cursor pagination built in. Search, aggregations, and CRUD through one consistent interface.
Auto-generated REST and GraphQL APIs from collection config. Consistent CRUD patterns. Depth and locale query params are powerful.
Store and Admin API separated cleanly. Cursor pagination on list endpoints. Consistent resource naming. v2 improved API design significantly.
v2 API is cleaner than v1. Booking, availability, and event type endpoints follow REST conventions. Webhook reliability improving.
gRPC-first with protobuf schemas. Consistent service definitions. HTTP API available via grpc-gateway. Strong typing from proto files.
HTTP Event API is simple. Cohort and taxonomy APIs are separate with different conventions. Rate limits well-documented per endpoint.
Clean REST API for flags, identities, and segments. Self-hostable. API is well-documented with OpenAPI spec. Consistent resource patterns.
Clean REST API for incidents, services, and escalation policies. Error responses include code and message consistently. Webhooks v3 are reliable.
Well-designed REST API. Block model is verbose but consistent. Cursor pagination on all list endpoints. Date-based versioning via Notion-Version header.
REST API for reading file data and components. Webhooks for file updates. Consistent JSON responses. Rate limits are generous for read operations.
Admin API is RESTful and consistent. CRUD for routes, services, and plugins follows predictable patterns. Error responses include message and fields.
Consistent REST API across all secret engines. Every endpoint returns same envelope format. Auth methods use standard request patterns.
HTTP API for queries and metadata. Consistent result types (matrix, vector, scalar). PromQL passed as query parameter. Simple and functional.
HTTP API for dashboards, datasources, and alerts. Consistent JSON envelope. API keys and service accounts for auth. Some endpoints underdocumented.
REST API with JSON query DSL. Scroll and search_after pagination for large datasets. Bulk API for efficient indexing. Error responses include root_cause chain.
NerdGraph (GraphQL) is the primary API. REST v2 exists for legacy. NRQL queries via GraphQL. Consistent error format in GraphQL responses.
Cloud API for cluster management is clean REST. Database access is Postgres wire protocol. Consistent resource naming for clusters, databases, and SQL users.
HTTP interface accepts SQL via POST body. Cloud API for management is separate REST. Consistent error format with exception code and stack trace.
Environment API v2 is well-structured. Consistent pagination with nextPageKey. Structured error responses. Webhook integrations for alerting are reliable.
v2 API is well-structured for pipelines and workflows. Consistent JSON envelope. Pagination via next_page_token. Webhook events for job status.
REST API auto-generated from gRPC definitions via grpc-gateway. Consistent protobuf-to-JSON mapping. Application sync and health endpoints are well-designed.
Remote cache API is simple — artifact upload and download. Team management endpoints are consistent. Small API surface but well-designed.
REST API for projects, issues, and orgs. Consistent error format with code and message. Pagination via offset/limit. Webhook notifications for new vulnerabilities.
v2 API for repos, commits, and coverage reports. Consistent JSON responses. GitHub/GitLab integration via status checks rather than webhooks.
REST API covers builds, projects, and agents. Locator syntax for filtering is powerful but unique. XML and JSON responses supported. Consistent HATEOAS links.
REST API for remote cache and distributed task execution. Consistent JSON responses. Access token auth. API surface is focused and clean.
REST API for package analysis and alerts. Consistent error format with type and description. Rate limits documented per endpoint. Webhook alerts for supply chain issues.
Develocity (ex-Enterprise) REST API for build scans and cache. Consistent JSON responses. Build scan API is well-documented. Open-source Gradle has no API.
Swagger-documented REST API mirrors Docker API patterns. Consistent CRUD for stacks, containers, and environments. JWT auth. Webhook for container events.
JSON:API-conformant REST. Consistent envelope for resources and relationships. Webhook signatures via HMAC. Filter syntax follows JSON:API spec.
Pipe endpoints expose SQL queries as parameterized REST. Pagination via page_size and cursor. Errors include ClickHouse exception codes.
REST + gRPC API for app management. Most usage is via Python SDK. Function invocation has consistent request/response shapes.
GROQ query language is powerful but proprietary — adds learning curve. REST and GraphQL APIs sit on top. Mutations API is consistent. Webhook payloads include document diffs. Auto-generated GraphQL lags schema changes by a few seconds.
OpenAI-compatible chat API with citations in responses. Limited API surface (chat only). Search-augmented generation is the differentiator. Error format follows OpenAI convention.
REST API for room management and token generation. WebRTC signaling via WebSocket. Webhook events for room lifecycle (join/leave/recording). Egress API for recording/streaming is well-designed.
REST API for triggering notifications and managing subscribers. Workflow API is declarative. Multiple channel types (email, SMS, push, in-app) through one interface. Webhook execution logs available.
REST API for room management and storage. Real-time collab via WebSocket. Webhook events for room changes. Yjs and CRDT backends exposed through consistent API. Error responses include requestId.
SDK-first approach. REST API exists but feels like an afterthought. Inconsistent across products.
Admin API is clunky. Data API (recently added) is better but limited.
API is functional but underdocumented. Many platform features only available via dashboard, not API.
Machines API is functional but docs are sparse. GraphQL API deprecated in favor of REST. Inconsistent error shapes.
Ingestion API is simple. Export and query APIs use different conventions. JQL and custom queries are powerful but inconsistent.
REST API exists for workflow management but is secondary to the visual editor. Execution and workflow endpoints are functional but inconsistent.
REST and WebSocket APIs for queries. Custom query language (SurrealQL) adds power but learning curve. API surface still evolving.
API exists but is secondary to dashboard usage. Endpoints for applications, databases, and deployments. Documentation is minimal.
REST API v3 is better than v2 but still inconsistent. JQL for search is powerful. Error messages vary wildly across endpoints.
REST API v2 improved consistency. Board items use CRUD patterns. OAuth 2.0 flow is standard. Some endpoints still feel incomplete.
Platform API for managing Zaps is functional. Integration developer API uses CLI-defined schemas. Natural Language Actions API is novel but inconsistent.
REST API returns XML by default (JSON optional). SPL queries via search endpoint. Async job model for long queries. Enterprise-grade but dated design.
v2 REST API with token auth. Write API uses line protocol. Query API uses Flux or SQL (v3). Consistency improved in v2 but Flux adds complexity.
Dashboard API is read-only and minimal. Configuration is file/label based, not API-driven. API exists for inspection but not management.
REST API v2 covers repos, PRs, and pipelines. Consistency varies across endpoints. Error messages often lack actionable detail.
REST API mirrors Kubernetes resource patterns. Collection pagination via continue token. Error format varies between Rancher-native and proxied K8s errors.
Web API with 100+ endpoints. Consistency varies — older endpoints use different patterns. Page-based pagination. Webhook on quality gate status change.
No public REST API — operates via Git platform APIs. Self-hosted has a minimal HTTP API for status. Config is JSON-based, not API-driven.
Microservices architecture means multiple APIs (Gate, Orca, Clouddriver). Consistency varies between services. Pipeline execution API is the most used.
No cloud API — Biome is a local tool. LSP integration for editors is the 'API'. WASM builds for browser usage. Configuration is JSON-based.
Build Event Protocol uses gRPC/protobuf. Remote execution API is well-specified. No REST API — Starlark build language is the interface. Remote cache API is S3-compatible.
JSON API exists but is an afterthought. No consistent error format. Pagination is depth-based and clunky. Authentication via crumbs is unique and annoying.