Ship AI in your app, keep control on your server
Wavelike is the gateway between your app and every model, so provider keys stay off the device and you can govern and debug every request in production.
For teams shipping AI in native and web apps. We'll follow up with next steps.
- Requests, payloads + latency
- Production debugging
- Text, media + compaction
- Model routing
- Auth, quotas + attribution
- Per-user controls
Client integration + dashboard control
import Wavelike Wavelike.set(environment: .production)Wavelike.set(appId: "app_live_...")Wavelike.set(auth: .backend(userId: user.id, key: userKey)) let model = Wavelike.model( for: ModelIdentifier(ModelClient.self, id: "support-chat")) let receipt = try await Wavelike.uploadFile(at: receiptURL) let response = try await model.sendText(history: [ Message(role: .user, parts: [ .inputText("Summarize this receipt"), .inputFile(uploadedFile: receipt), ])])Responses
Chat, tools + schemas
Attribution
BYOK, keys + app users
Forensics
Files, media + traces
Routes client traffic to the providers, private endpoints, and API surfaces your apps already use
Supported providers include OpenAI, Anthropic, OpenRouter, Together AI, Google, AWS Bedrock, xAI, and Fireworks AI.
Built for developers
The missing control plane between your app and every model.
Shipping AI in a client app means provider keys on devices you don't control, no view into what users actually send, and bills you can't attribute. Wavelike sits in the request path and fixes all three.
Client AI Gateway
- Give your app one OpenAI-compatible API. Wavelike handles credentials, validation, routing, and response normalization on the server.
BYOK Routing
- Route calls through Wavelike-managed providers, your own keys, custom endpoints, or self-hosted tunnels, without shipping upstream secrets to clients.
Identity
- Gate every request with dashboard-managed auth, from API keys and backend-issued user keys to SSO and device attestation.
Spend Intelligence
- See exactly what is driving your AI bill, sliced by app, user, key, route, provider, or model.
Request Observability
- Debug gateway and on-device calls with searchable logs, full stored payloads, latency phases, and per-user attribution.
Quota Policies
- Cap cost, tokens, or requests per user, key, or model route, enforced before the provider call ever goes out.
Model Stacks
- Create one app-facing model that sends each job to the right underlying model: text, compaction, image input/output, and audio input/output.
SDKs
- Drop in the iOS SDK and WavelikeUI chat components, or call the OpenAI-compatible HTTP endpoints from anywhere.
Every request passes through policy
Requests are validated, attributed to an app user or API key, checked against quotas, routed to the right model for the job, normalized, and logged before the response returns to the client.
Integrate without a backend rewrite, or a backend at all
Use Wavelike behind an existing service, or let Wavelike be the backend your client calls for identity, model access, file uploads, provider credentials, quotas, multi-model routing, and exportable usage records.
Turn production requests into evidence
The request detail page turns payload JSON into a readable visual debugger for prompts, responses, stream events, tool calls, output schemas, uploaded files, media, SDK metadata, local-model records, and provider failures. Filter the history, then export the matching requests as JSONL.
Private beta access
Join the private beta for controlled AI in client apps.
Get early access to the dashboard, API gateway, iOS SDK, auth strategies, quota policies, BYOK routing, multi-model routing, and visual request forensics.
Join the waitlist and we'll follow up with private beta access.