Official vendor OpenAPI document · agent-readyAI/MLLanguage Modelsbearer20 EndpointsREST
For Agents
Create chat completions, generate media from media models, and run isolated code sandboxes with file and process access. Reports usage through a billing summary across 20 endpoints.
Use for: Create a chat completion with a chosen model, List the LLM models available on Dexto, Generate an image or video from a media model, Estimate the cost of a media generation before running it
Not supported: Does not train or fine-tune models, host your application, or store long-term data. Use for running LLM and media model inference and ephemeral code sandboxes only.
The Dexto API bundles three AI infrastructure surfaces behind one key: it creates chat completions against a catalog of LLM models, generates media from media models with recommendations and cost estimates, and runs isolated code sandboxes. Sandboxes can be created, started, paused, and deleted, and an agent can list, read, write, and delete their files and execute processes inside them. A billing summary reports usage across the models and sandboxes it runs.
Install Jentic One Beta
Connect the Dexto API to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Dexto API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fdexto.ai%2Fdexto" | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fdexto.ai%2Fdexto" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with Dexto API.
Create chat completions against a catalog of LLM models
Generate media from media models, with model recommendations and cost estimates before running
Track media generation jobs by id and list past generations
Create, start, pause, and delete isolated code sandboxes
Read, write, list, and delete files inside a sandbox
Execute a process inside a sandbox and capture its result
Read a billing summary of usage across models and sandboxes
Use Cases
Patterns agents use Dexto API for, with concrete tasks.
★ Unified AI Backend for an Agent
An AI agent connected to Dexto through Jentic can reach language-model completions, media generation, and code execution from a single credential rather than wiring three providers. It can create a chat completion for reasoning, start a media generation for an asset, and spin up a sandbox to run code, all under one key with one billing summary to watch.
Create a chat completion to draft a script, then create a sandbox and execute the script as a process
Cost-Aware Media Generation
Dexto lets a caller list media models, request a recommendation for a task, and create an estimate before starting a generation, so the cost is known up front. The generation then runs as a job that can be polled by id and listed afterward, which suits batch asset creation where spend needs to stay predictable.
Create a media estimate for a requested image, start the generation, and poll it by id until it completes
Isolated Code Execution
Dexto's sandboxes give an agent a disposable environment to run code: create a sandbox, write files into it, execute a process, read the output, then pause or delete it. Because each sandbox is isolated and carries its own id, an agent can run untrusted or generated code without touching the host environment.
Create a sandbox, write a Python file, execute it as a process, read the result, then delete the sandbox
Model Selection and Billing
Before and after running work, Dexto exposes the available LLM and media models and a billing summary of usage. An agent or operator can pick a model from the catalog, run inference or generation, and read the billing summary to track consumption across both inference and sandbox time.
List the available models, run a chat completion against one, and read the billing summary to confirm the usage recorded
Key Endpoints
20 endpoints — the dexto api bundles three ai infrastructure surfaces behind one key: it creates chat completions against a catalog of llm models, generates media from media models with recommendations and cost estimates, and runs isolated code sandboxes.
METHOD
PATH
DESCRIPTION
POST
/v1/chat/completions
Create a chat completion
GET
/v1/models
List available LLM models
POST
/v1/media/generations
Start a media generation
GET
/v1/media/generations/{generation_id}
Get a media generation job by id
POST
/v1/sandboxes
Create a sandbox
POST
/v1/sandboxes/{sandbox_id}/processes
Execute a process inside a sandbox
POST
/v1/sandboxes/{sandbox_id}/files/write
Write a file inside a sandbox
GET
/v1/billing/summary
Get a billing summary of usage
POST
/v1/chat/completions
Create a chat completion
GET
/v1/models
List available LLM models
POST
/v1/media/generations
Start a media generation
GET
/v1/media/generations/{generation_id}
Get a media generation job by id
POST
/v1/sandboxes
Create a sandbox
POST
/v1/sandboxes/{sandbox_id}/processes
Execute a process inside a sandbox
POST
/v1/sandboxes/{sandbox_id}/files/write
Write a file inside a sandbox
GET
/v1/billing/summary
Get a billing summary of usage
Jentic AI Readiness Score
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
D
Dexto API
- Non-Ready (F)28/100
7
Foundational Compliance69
Developer Experience & Jentic Compatibility40
AI-Readiness & Agent Experience94
Agent Usability60
Security75
AI DiscoverabilityPowered by JenticScoring Framework 1.0.0 | Scoring Engine 0.4.2
Show dimension breakdown
7
Foundational Compliance
Base layer of spec validity and structural soundness.
Grade: FSignals: 4
0%
Lint Results
Aggregated quality score from linter diagnostics, weighted by severity.
0%
Resolution Completeness
Percentage of `$ref` references that resolve successfully.
0%
Specification Validity
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
30%
Structural Integrity
Structural correctness score based on schema issues using logarithmic dampening.
69
Developer Experience & Jentic Compatibility
Clarity, completeness, and ingestion readiness for developers and tooling.
Grade: B+Signals: 4
0%
Example Density
How richly the API is illustrated with examples.
100%
Example Validity
Percentage of examples that conform to their schemas.
75%
Response Coverage
Percentage of operations with complete response definitions (success, client error, server error).
100%
Tooling Readiness
Health of API ingestion, bundling, and resolution within Jentic pipelines.
40
AI-Readiness & Agent Experience
Semantic breadth, depth, and agent comprehension for AI systems.
Grade: FSignals: 4
6%
Description Coverage
Coverage of descriptions across API elements.
0%
Error Standardization
Coverage of RFC 9457 Problem Details for error responses.
100%
OperationId Quality
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
53%
Summary Coverage
Coverage of summaries across operations/tags/info.
94
Agent Usability
Functional utility, complexity comfort, and AI orchestration readiness.
Grade: A+Signals: 1
94%
Complexity Comfort
Agent comfort level based on API operational and structural complexity.
60
Security
Trust, risk posture, and security compliance.
Grade: B-Signals: 1
60%
Authentication Strength
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
75
AI Discoverability
Findability, semantic richness, and reasoning readiness.
Grade: A-Signals: 1
75%
Descriptive Richness
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>Why Jentic?
What agents get from Jentic-routed access to this vendor.
Setup
Wiring Dexto by hand means handling its bearer API-key auth and three separate surfaces: chat completions, media generation with its own model catalog and estimates, and code sandboxes with file and process operations. Through Jentic you install once, import Dexto from the API Directory, store the key once, and your agent calls it.
Permission scoping
Dexto groups its surface into inference (chat completions and media generation) and sandboxes, and each sandbox carries its id in the URL path (/v1/sandboxes/{sandbox_id}/...). A rule can let your agent create completions and media generations while sandbox deletion and process execution stay out of its reach, or pin sandbox access to one sandbox id. You choose the operations it may call, so arbitrary code execution is not included unless you add it.
Credential isolation
Your Dexto API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'create a chat completion' or 'run code in a sandbox', and Jentic returns the matching Dexto operation with its input schema so the agent calls the right endpoint without browsing the reference docs.
Related APIs
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using Dexto API through Jentic.
Is there a Dexto MCP server?
You don't need an MCP server to give your agent Dexto. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent calls the chat-completion, media-generation, and sandbox operations. Operations are discovered on demand, so no extra server's tool definitions sit in the agent's context.
Can I limit what my agent is allowed to do with Dexto?
Yes. Write a rule that allows the chat-completion and media-generation operations but not sandbox process execution or deletion, so the agent can run inference while arbitrary code execution stays off, and every call it makes is logged.
What authentication does the Dexto API use?
Per its OpenAPI spec, the Dexto API uses a bearer Dexto API key sent in the Authorization header for all operations. Through Jentic the key is stored encrypted by your own Jentic One instance and injected only at call time, so it never sits in the agent's prompt or logs.
Can I run code in a sandbox with the Dexto API?
Yes. The create-sandbox operation provisions an isolated environment, and you can write files into it, execute a process, and read the output before pausing or deleting it. Each sandbox carries its own id in the path, so file and process operations are scoped to a specific sandbox.
What are the rate limits for the Dexto API?
The OpenAPI spec does not specify request-rate limits; usage is instead tracked through the billing summary operation, which reports consumption across models and sandboxes. Check dexto.ai for current limits and pricing.
How do I generate media with the Dexto API through Jentic?
Create a media estimate to preview the cost, start the generation, then poll it by generation id until it completes. In Jentic, search for 'generate media from a model', store your API key once, and the agent runs the sequence. To run it on your own infrastructure, install Jentic One from its GitHub repo.
GET STARTED