Features — AI Gateway for Amazon Bedrock¶

stdapi.ai is an AI gateway purpose-built for AWS. It brings full OpenAI, Anthropic, and Cohere API compatibility to Amazon Bedrock and AWS AI services — so any tool, SDK, or application your team already uses connects instantly, without code changes.

How It Works¶

stdapi.ai sits between your applications and AWS services, translating OpenAI, Anthropic, and Cohere API calls into native AWS requests. Any tool or SDK that speaks one of the three protocols connects instantly — no plugins, no custom integrations.

%%{init: {'flowchart': {'htmlLabels': true}} }%%
flowchart LR
  openwebui["<img src='../styles/logo_openwebui.svg' style='height:48px;width:auto;vertical-align:middle;' /> Open WebUI"] --> stdapi["<img src='../styles/logo.svg' style='height:64px;width:auto;vertical-align:middle;' /> stdapi.ai"]
  n8n["<img src='../styles/logo_n8n.svg' style='height:48px;width:auto;vertical-align:middle;' /> n8n"] --> stdapi
  ide["<img src='../styles/logo_vscode.svg' style='height:48px;width:auto;vertical-align:middle;' /> IDE + AI Assistant"] --> stdapi
  openai_app["<img src='../styles/logo_openai.svg' style='height:48px;width:auto;vertical-align:middle;' /> Any OpenAI App"] --> stdapi
  anthropic_app["<img src='../styles/logo_anthropic.svg' style='height:48px;width:auto;vertical-align:middle;' /> Any Anthropic App"] --> stdapi
  stdapi --> bedrock["<img src='../styles/logo_amazon_bedrock.svg' style='height:48px;width:auto;vertical-align:middle;' /> Amazon Bedrock"]
  bedrock --> claude["<img src='../styles/logo_anthropic_claude.svg' style='height:36px;width:auto;vertical-align:middle;' /> Claude"]
  bedrock --> qwen["<img src='../styles/logo_qwen.svg' style='height:36px;width:auto;vertical-align:middle;' /> Qwen"]
  bedrock --> mistral["<img src='../styles/logo_mistralai.svg' style='height:36px;width:auto;vertical-align:middle;' /> Mistral"]
  bedrock --> stability["<img src='../styles/logo_stabilityai.svg' style='height:36px;width:auto;vertical-align:middle;' /> Stability AI"]
  bedrock --> more["✨ and more..."]
  stdapi --> transcribe["<img src='../styles/logo_amazon_transcribe.svg' style='height:48px;width:auto;vertical-align:middle;' /> Amazon Transcribe"]
  stdapi --> polly["<img src='../styles/logo_amazon_polly.svg' style='height:48px;width:auto;vertical-align:middle;' /> Amazon Polly"]
  stdapi --> s3["<img src='../styles/logo_amazon_s3.svg' style='height:48px;width:auto;vertical-align:middle;' /> Amazon S3"]

Why stdapi.ai?¶

API Compatibility¶

Your existing applications, SDKs, and tools work immediately — no plugins or client changes needed.

Supported Endpoints¶

OpenAI-Compatible:

Anthropic-Compatible:

Cohere-Compatible:

stdapi.ai Native:

Parameter Coverage¶

stdapi.ai maps as many parameters as possible to Bedrock equivalents — across all routes, not just chat:

• Generation controls — temperature, max_tokens, top_p, top_k, stop, seed, frequency_penalty, presence_penalty, logit_bias, top_logprobs, streaming via SSE, token usage reporting
• Reasoning — reasoning_effort (none/minimal/low/medium/high/xhigh), enable_thinking, thinking_budget
• Tool / function calling — Full OpenAI and Anthropic schemas, parallel tool calls, tool choice modes
• All content types — System, developer, user, assistant, and tool roles; text, image, audio, video, and document content
• Response formats — JSON object, JSON schema, streaming chunks, reasoning_content, annotations
• Model-specific extras — Any parameter beyond the standard API via extra_body or top-level request fields

100+ Models Across 10+ Providers¶

Access every model available on Amazon Bedrock through a single, consistent API — including OpenAI GPT, xAI Grok, and other frontier models.

Model Management¶

• Automatic model discovery — Scans configured regions at startup; no manual model list to maintain
• Model aliases — Map custom names to Bedrock model IDs; Claude and OpenAI names resolve automatically
• Deprecated model failover — Requests to retired models transparently redirect to their replacements
• Legacy model filtering — Optionally hide deprecated models from the models list

Multi-Modal Capabilities¶

Text & Conversational AI¶

• All message roles: system, developer, user, assistant, tool
• Multi-turn conversations with full history
• Tool / function calling with parallel execution
• Structured JSON output (JSON object and JSON schema modes)
• Streaming via Server-Sent Events with real-time token delivery
• Reasoning content blocks (thinking, reasoning_content) for supported models
• Web search results as context (search_result content blocks)

Images¶

Generation — Text-to-image with:

• Multiple output formats: PNG, JPEG, WebP with adjustable quality and compression
• Flexible sizes and aspect ratios
• Streaming generation with partial image previews
• Style presets (model-specific)

Editing — Inpainting and transformation:

• Mask-based inpainting (define edit regions precisely)
• Image-to-image transformation (style, structure conditioning)
• Background removal, object search & replace, object recolor
• Creative and conservative upscaling

Variations — Create alternative versions of existing images

JSON body format — Reference images via Files API file_id or URL instead of re-uploading

Audio¶

Text-to-Speech (Amazon Polly):

• 60+ voices across 30+ languages
• Multiple engine tiers: Standard, Neural, Long-Form, Generative
• SSML support — control pronunciation, emphasis, pauses, prosody
• Output formats: MP3, PCM, Opus, AAC, FLAC, OGG Vorbis
• Speed control (0.2× to 2.0×)
• Automatic language detection via Amazon Comprehend

Speech-to-Text (Amazon Transcribe):

• 100+ languages
• Speaker diarization — automatic speaker separation and labeling
• Word-level and segment-level timestamps
• Subtitle export: SRT and VTT formats
• Vocabulary customization and custom language models
• Automatic language detection

Speech Translation — Transcribe audio and translate to English in a single request

Documents & Files¶

• PDF input with optional citation support (precise source references in responses)
• Plain text and structured content blocks as context
• File storage via the Files API — upload once, reference by ID across multiple requests
• Multipart uploads for large files via the Uploads API (S3 native multipart)
• File expiry with configurable TTL (1 hour – 30 days)

Video¶

• Text-to-video and image-to-video generation (Amazon Nova Reel, Luma Ray 2) via the OpenAI Videos API
• Asynchronous job workflow — create, list, poll, download, delete — with stateless job tracking
• Video input in chat completions for supported models (e.g., Amazon Nova)
• S3 URLs as direct video input for multimodal embeddings

Embeddings¶

• Text embeddings — single and batch processing
• Multimodal embeddings — images, audio, video, PDF documents
• Dimension control (model-specific reduction)
• Float or Base64 output encoding
• S3 URL input for large files; oversized base64 payloads auto-uploaded to S3

Purpose-Built for AWS¶

Multi-Region Routing & Quota Headroom¶

Configure multiple AWS regions to draw on more than one Bedrock quota and to keep serving when one region is degraded:

• Each region adds its own quota — Bedrock tokens-per-minute and requests-per-minute limits are per region, so a multi-region deployment draws on several independent quotas rather than one. How much of that headroom a workload reaches depends on the quota granted per model in each region and on the routing strategy
• Regional retry — eligible failures switch region transparently on throttle, quota, or service errors. Streaming responses can only retry before the stream opens, and asynchronous jobs stay in the region that accepted them
• Exponential backoff — doubles per consecutive error, capped at 1 hour
• Region health tracking — per-model health status with configurable recovery delays

Resilience & Failover

Advanced Bedrock Features¶

Bedrock Mantle Models¶

stdapi.ai serves models from the Amazon Bedrock Mantle endpoint alongside the classic Bedrock catalog: OpenAI GPT, xAI Grok, Google Gemma, Qwen, GLM, DeepSeek, MiniMax, Kimi, Nemotron, and more — the available catalog varies per region and grows over time.

• Every text API, every model — All four text APIs (chat completions, responses, messages, legacy completions) work with every Mantle model: served natively (passthrough) when the model supports the API upstream, converted automatically otherwise, with an automatic fallback order (responses → chat completions → messages) learned at runtime
• Predictable routing — Models available on both the classic endpoint and Mantle are served by the classic endpoint by default; Mantle serves Mantle-only models. Dual-homed models can be routed through Mantle globally or per request (x-stdapi-service: bedrock-mantle header) to tap Mantle's separate throughput quotas
• Region failover — Region failover and quota backoff work exactly like classic Bedrock region routing; requests chained via previous_response_id are pinned to their origin region
• No static secrets — Mantle access uses the same AWS credential chain as the rest of the server; there is no separate API key to issue, store or rotate
• Native stored conversations — /v1/responses with store, previous_response_id, and GET/DELETE /v1/responses/{id} use Mantle's native server-side storage: 30-day retention, region-local, project-scoped
• Usage & billing — Token usage (including cached tokens and standard/flex/priority service tiers) is recorded and priced at bedrock-mantle rates, like all other models

Enabled by default; regions, routing preferences, the per-request Mantle routing header, and required IAM permissions are covered in the Bedrock Mantle configuration and IAM sections — without the required permissions, Mantle models are simply not listed and a warning is logged at startup.

Bedrock Mantle Configuration

AWS AI Services Integration¶

Amazon S3 Integration¶

S3 is woven into the entire API surface — not just file storage:

• Files API — Full CRUD at /v1/files with no artificial size limit (up to S3's ~5 TB), optional expiry, S3 Lifecycle backstop; file IDs work across both OpenAI and Anthropic endpoints
• Multipart uploads — /v1/uploads backed by S3 native multipart; stream large files without buffering
• Direct s3:// image references — Use s3://bucket/key in chat completions and Anthropic Messages; the gateway reads from S3 via IAM role — no pre-signed URLs
• Files API in image operations — Reference uploaded files by file_id in image edits and variations
• Multimodal embeddings — Pass s3:// URLs directly; oversized base64 payloads auto-uploaded and invoked asynchronously
• Regional buckets — One bucket per Bedrock region; S3 region routing is automatic
• Transfer Acceleration — Faster downloads via generated HTTP links

Security & Compliance¶

Authentication¶

stdapi.ai supports multiple authentication strategies to fit your architecture:

Authentication & Security

Security Features¶

Compliance & Data Sovereignty¶

AWS service calls are restricted to the regions you configure. The AWS services used by stdapi.ai (Bedrock, S3, Polly, Transcribe, and more) are in scope for GDPR, ISO 27001/27017/27018, SOC 1/2/3, HIPAA, FedRAMP, PCI-DSS, and CSA STAR Level 2 — these certifications apply to the AWS services and regions you choose, and are not inherited by stdapi.ai or by your application. The commercial Terraform module adds VPC endpoints (no internet egress), Customer Managed KMS keys, and region-pinned cross-region profiles for strict data residency.

Data Sovereignty & Compliance

Works with Your Existing Tools¶

stdapi.ai is a drop-in replacement in hundreds of applications and tools. Change the API endpoint — nothing else.

See all use cases

AI Agents¶

Agent Discovery¶

AI agents can automatically discover the API's capabilities through standardized RFC 8288 Link headers and an API catalog:

• Link headers — Root endpoint (/) includes Link response headers advertising available resources (rel="service-desc", rel="service-doc") when documentation endpoints are enabled, and rel="mcp-server-card" when MCP is enabled
• API catalog at /.well-known/api-catalog — RFC 9727 machine-readable catalog (RFC 9264 Linkset format) listing the OpenAPI schema, documentation, and MCP server card
• MCP server card at /.well-known/mcp/server-card.json — SEP-1649 server card advertising available MCP transports and capabilities; active when MCP is enabled

Set ENABLE_OPENAPI_JSON=true to activate schema-based agent discovery — this exposes the machine-readable OpenAPI schema at /openapi.json and populates the Link headers and API catalog. ENABLE_DOCS and ENABLE_REDOC also enable it as a side effect, but those UIs are human-facing and not needed by agents.

MCP (Model Context Protocol)¶

stdapi.ai exposes its full API surface as MCP tools, letting AI agents and orchestrators call any endpoint directly through the Model Context Protocol — no HTTP client code required.

• Streamable HTTP transport — The recommended method, implementing the latest MCP Streamable HTTP specification at /mcp
• SSE transport — Available at /sse for backwards compatibility with older MCP clients
• All endpoints as tools — Every API operation (chat, images, audio, files, models) is surfaced as a named MCP tool with generated documentation
• Selective exposure — Include or exclude tools by name to limit scope and reduce agent confusion
• Context-optimized tools — Tool schemas hide parameters MCP clients cannot use (streaming modes, token-level tuning, caller identifiers), and tool results are returned as compact JSON, cutting the tokens each call costs the calling agent
• Automatic timeout alignment — MCP calls respect the global AI_RESPONSE_TIMEOUT setting

# Enable MCP via HTTP (recommended)
export ENABLE_MCP_STREAMABLE_HTTP=true

# Restrict to safe, read-oriented tools
export MCP_EXCLUDE_TOOLS="openai_files_delete,anthropic_files_delete"

Example use cases:

MCP Configuration

Observability & Operations¶

Structured Logging¶

• JSON logs to stdout — natively ingested by CloudWatch Logs
• Every request logs: method, path, status, model ID, region(s) used, execution time
• Optional: full request/response payloads, client IP (disabled by default)
• Configurable log levels (info, warning, error, critical, disabled)

OpenTelemetry Integration¶

• Export traces and metrics to AWS X-Ray, Datadog, Jaeger, or any OTLP-compatible backend
• Configurable sampling rate
• Root span per request with full correlation IDs

Token Usage Tracking¶

• Input, output, reasoning, and cached token counts in every API response
• Consistent reporting across all endpoints (chat, messages, embeddings, images, audio)

Cost Tracking¶

• Usage counts read back from AWS — Token, character, second, and image counts come from the AWS responses themselves rather than from client-side counting; recorded per request across chat, embeddings, images, audio, and built-in tools
• Priced from the published AWS Price List — Costs computed from AWS's own price list, refreshed automatically; no manual price list to maintain (operator overrides available for gaps)
• Priced on the dimensions AWS bills on — Each call is priced with everything AWS prices differently: serving region, service tier (standard/flex/priority/batch, using the tier that actually served the call), prompt-cache TTLs, cross-region and latency-optimized routing, long-context rates, and image resolution/quality
• Per-request and aggregate cost — Request log entries carry cost and currency as exact decimal strings, with a per-request total rollup
• Multi-currency aware — Detects your AWS partition's currency (USD, EUR, CNY) and never sums costs across currencies
• Model Pricing API — Query the loaded catalog through GET /model_pricing for cost-aware model selection, also exposed as an MCP tool
• Optional CloudWatch cost metrics — Track spend alongside your other operational metrics via EMF

Developer Tools¶

• Swagger UI at /docs — test endpoints directly in your browser
• ReDoc at /redoc — clean, searchable API reference
• OpenAPI schema at /openapi.json — import into Postman, generate client code

Quality of Life¶

• Model list caching — Fast model listing without repeated AWS API calls
• Safety identifier — safety_identifier field in requests as an alias to user for abuse tracking and audit trails
• Zero-configuration startup — Automatic region and model detection; warnings on missing config

Performance¶

A gateway earns its place by adding as little as possible on top of the model call. Every hot path here follows two principles: run independent work at the same time, and touch each byte once, in native code.

• Parallel where it counts — Independent work fans out concurrently; a request finishes with its slowest item, not the sum of them
• Native code end to end — JSON encoding and decoding, the AWS wire format, and the HTTP serving stack all run compiled, on an optimized event loop
• Every byte touched once — Requests are parsed and validated once, responses encoded once, payloads moved without redundant copies — no duplicate work between layers or toward AWS

Measured on the production serving stack, single worker, over the complete request path:

Typical requests are dominated by the fixed sub-millisecond serving floor; the optimizations above pay off precisely where load does — large contexts and streaming.

Quality Assurance¶

"OpenAI-compatible" is easy to claim and hard to keep. The gateway sits between your application and a set of backends that change underneath it — new model generations, new parameters, silently altered behaviour — so its test suite is built to catch that drift before you do.

Compatibility is proven against the real APIs, not against our own docs¶

A gateway tested only against itself proves only that it is self-consistent. The suite runs the same test bodies against the genuine OpenAI, Anthropic and Cohere endpoints, changing nothing but the URL. A test that passes here and fails there is treated as a compatibility bug in this product — not as an acceptable difference.

That distinction is enforced when a test is written, before the feature exists: the expected behaviour is captured from the vendor's own API first, so the implementation is written to match a contract that was verified, not assumed.

Real applications, not just API calls¶

Passing an HTTP test says nothing about whether a real coding agent, chatbot or automation platform actually works. So the suite runs them: complete third-party client software, unmodified, against a live gateway — coding agents (Claude Code, Codex, pi, OpenClaw, Hermes, Qwen Code), the n8n workflow runner, a Haystack RAG pipeline, the Open WebUI chat interface, Home Assistant's voice bridge, and the LangChain and pydantic-ai Python libraries — driving multi-turn tool-calling sessions, document retrieval and reranking, and speech pipelines across dozens of models and all three API dialects. A regression that only appears in a real client is caught here, not by you.

Every model is measured, not assumed¶

Model documentation describes what a model is supposed to accept. What it actually accepts is something else, and it changes between generations of the same model family. Each supported model is probed empirically for the parameters and features it genuinely honours — including the parameters it accepts and then quietly ignores, which are the ones that silently produce a wrong answer. The results are recorded and the behaviour is pinned by tests.

What runs, and when¶

No release ships without the full suite passing against a real deployment of the exact build being released.

Beyond automated tests¶

• Static analysis and strict typing on every line of source and test code
• Documented behaviour is tested behaviour — the compatibility tables on these pages are derived from what the tests assert, so a change in behaviour that the docs do not reflect fails the build
• Continuous review — periodic audits of the codebase and of the test suite itself, because a passing test that asserts nothing is worse than no test
• Security scanning of dependencies and container images, with the commercial image validated against AWS Security Hub's Foundational Security Best Practices

Deployment¶

Community vs Commercial¶

How stdapi.ai Compares¶

All four solutions below expose an OpenAI-compatible API in front of Amazon Bedrock. The comparison focuses on the AWS deployment context — LiteLLM is evaluated with AWS services as the backend provider (Bedrock, Polly, Transcribe), not as a multi-cloud proxy. Bedrock Access Gateway is the official AWS-maintained open-source sample. Bedrock Mantle is AWS's own managed OpenAI-compatible endpoint, requiring no self-hosting — and stdapi.ai can also front it as an additional backend, serving Mantle-only models through the gateway (see Bedrock Mantle Models).

Competitor capabilities were verified against official sources on 5 August 2026. stdapi.ai is AWS-only: if you need multi-cloud routing or spend limits enforced at request time, LiteLLM is the better fit.

Ready to Get Started?¶