AI API
One API for agents, RAG, memory and tools
Model routing, function orchestration, knowledge retrieval and guardrails behind a single call.
No credit card · First call in about five minutes
curl --location 'https://api.gtwy.ai/api/v2/model/chat/completion' --header 'pauthkey: <your-auth-token>' --data '{
"agent_id": "<agent_id>",
"thread_id": "<thread_id>",
"user": "<Your query>?",
"user_urls": [],
"variables": {}
}'{
"response": {
"data": {
"id": "resp_0b7dbf08…c7cb",
"content": "Hi there",
"model": "gpt-5-nano",
"role": "assistant"
},
"usage": {
"total_tokens": 11113,
"input_tokens": 7999,
"output_tokens": 3114,
"cached_tokens": 0,
"reasoning_tokens": 2176,
"cost": 0.00164555
}
}
}What you don’t build
The part that isn’t the fun part.
Six to nine months of plumbing, behind one endpoint.
The core
One call, everything underneath it.
A single call can trigger a model call, several tool calls, a knowledge lookup and guardrail checks. All of it is one run.
Prototype ready
One API key · A prompt that works · Demo shipped
stall for months
AI in production
The uptime your customers expect · The compliance your buyers ask for · Real ROI
The easy part
- The demo answers correctly
- Stakeholders are impressed
- Budget approved
- One LLM call, one happy path
The engineering drag
6–9 months of plumbing- Model routing & failover
- Vector DBs & indexing pipelines
- Memory & conversation state
- Function orchestration
- Guardrails & rate limiting
- Logs, traces & observability
- Integrations to build and maintain
- Compliance and data residency
Fully managed
- One API for agents, RAG & chatbots
- Real-time indexing, no pipelines
- 2,000+ integrations, ready to call
- Observability and failover included
Your AI works in a demo.
Now comes the engineering drag.
Between a prompt that works and AI your business can run on sits routing, memory, indexing, integrations and infrastructure. GTWY turns your AI ideas into production — without the infrastructure pain.
This AI doesn’t just talk.
It gets things done.
Seamless connectivity
2000+
App integrations
Agents that can use tools — instantly. Connect your stack and GTWY handles the calls, updates, and actions.
Models
Switch providers without changing your code.
Pick a model per run, name one fallback, and a provider outage degrades a run instead of taking down your feature.
Built on GTWY
What people are shipping.
Standup summariser
Reads yesterday’s commits and writes the standup note.
github.prs · slack.notifyClone →Invoice reader
Pulls line items out of PDFs and reconciles them against the ledger.
knowledge · sheets.appendClone →Changelog writer
Turns merged pull requests into release notes.
github.prs · notion.pageClone →Pricing
Start free. Pay for what you run.
Free
Enough runs to build something real. No card.
Pay as you go
Per run, on a card. No sales call.
Enterprise
Volume, dedicated infrastructure, custom terms.
Questions
What developers ask first.
What counts as one run?
One complete agent task. Model calls, tool calls, agent-to-agent hops, knowledge lookups, fallbacks and retries inside that task are all part of the same run.
Which models are supported?
The major hosted providers — Anthropic, OpenAI, Google, Meta, Mistral, Cohere — selectable per run, each with a single fallback. The full table with context windows and prices is on the Models page.
Can I use my own model API key?
Yes. Add your own provider key and inference bills straight to your account at your own rate — we never touch it. The GTWY run fee is separate: top up your wallet and each run is deducted from the balance as it happens.
What are the rate limits?
Requests per minute on the free tier, raised on paid, with the remaining budget returned in response headers. Rate limits are separate from spend caps — one protects the infrastructure, the other protects your invoice.
Is there a free tier?
Yes — enough runs to build something real without a card. Exact limits are on the pricing page.
How is this different from calling OpenAI directly?
For a single completion, it isn’t. Call the provider directly and save the hop. It becomes different when you need memory across turns, tool execution with retries, retrieval over your own documents, routing and fallback between providers, and a trace of what actually happened — that is the part you would otherwise build and maintain yourself.