Copy the Dexto connector URL
Paste this URL into your client in the next step.
https://app.dexto.ai/mcp Getting started
Paste this URL into your client in the next step.
https://app.dexto.ai/mcp Open Customize → Connectors. Add Dexto and paste the URL.
Connect, sign in, then enable Dexto from Search and tools.
Claude MCP docsIn the ChatGPT desktop app, open Plugins, click the settings icon, select MCPs, then click Add server.
Choose custom MCP. Name it Dexto, select Streamable HTTP, paste the URL, then save. Complete sign-in and make sure Dexto is enabled.
ChatGPT / Codex MCP docsInstall the Dexto MCP server in one click.
Approve the install, then sign in to Dexto.
Cursor MCP docsSign in, then ask OpenClaw to use Dexto.
OpenClaw MCP docsSign in, then ask Hermes to use Dexto.
Hermes MCP docsUse server name dexto, URL https://app.dexto.ai/mcp, transport Streamable HTTP,
and OAuth. No Dexto CLI install or API key is needed for this path.
claude mcp add --transport http dexto https://app.dexto.ai/mcpOpen Claude Code, run /mcp, select dexto, and choose Authenticate. Finish sign-in and
consent in the browser, then return to Claude Code.
See Claude Code MCP setup.
codex mcp add dexto --url https://app.dexto.ai/mcpFinish the browser OAuth flow if prompted. If adding the server did not start sign-in, run
codex mcp login dexto. After authorization, start a new Codex session to load its tools.
See Codex MCP setup.
When you import Codex chats into Dexto (dexto import), each answer keeps the model that wrote it.
The chat continues on the model of its last answer. Run dexto connect codex to continue on your
ChatGPT plan; see
Continue imported chats on their model.
Merge this entry into .cursor/mcp.json (project) or ~/.cursor/mcp.json (all projects):
{ "mcpServers": { "dexto": { "url": "https://app.dexto.ai/mcp" } }}In Cursor’s MCP settings, enable dexto, choose Connect or Needs Login, and finish OAuth
in the browser. See Cursor MCP setup.
Add a remote Streamable HTTP server named dexto with the URL above. Enable OAuth and let
the client discover the authorization server from the resource metadata. Sign in to Dexto,
choose your organization, and approve the requested access in the browser. Do not paste tokens
into the configuration. After sign-in, load tools/list and ask for a read-only list of your chats.
An empty list is a successful result; starting a chat is not required.
The permissions depend on the client and the tools requested. The authoritative list is
https://app.dexto.ai/.well-known/oauth-protected-resource/mcp → scopes_supported;
the tool catalog lists each tool’s scopes. For example, listing chats needs
sessions:read; starting one needs sessions:write. Review the consent screen before approving.
billing:write and gpu:write require explicit requests. See Building a client
for discovery and the metered-compute exceptions.
After OAuth sign-in, Dexto introduces itself to your MCP client as four connected layers:
| Layer | What it gives you |
|---|---|
| Connect | Connections bring services such as GitHub and reusable account context into Dexto |
| Work | Capabilities perform direct actions; Agents and AutoBots take on delegated work |
| Reuse | Skills preserve useful procedures; Apps provide focused interactive experiences |
| Automate | Automations run recurring work autonomously |
For an unfamiliar task, ask your client to search Dexto first. Dexto returns a small ranked set of routes that are available to your account, why each route matched, whether setup is needed, and the next product action. Where a Dexto tool acts on a route, the route names that tool and the arguments to fill in. It does not paste the full catalog or tool schemas into the conversation.
Try prompts such as:
Search results can include Dexto operations and App actions, Capabilities, Skills, Agents, AutoBots, Apps, Connections, Automations, Services, and Marketplace resources. Search only names what your connection’s permissions reach. A result is a route, not a grant: Dexto checks current access, billing, and availability again when the client takes the next action.
Dexto search deliberately returns a small page. The server enforces the result limit, bounds every display field and the complete serialized response, and supplies a cursor when more matches exist. The client can move wider through outcome-family facets and the cursor, or move deeper by inspecting one promising route for its current affordances and a few related alternatives. Setup requirements are resolved before the client takes the owning product action.
A client can narrow a search to source types such as operation, app_action, skill or
connection; the search tool lists every type. Stable outcomes such as connect, work, reuse,
delegate, automate, and experience help the client understand how a result can be used. Exact
inputs become strict only when the client makes the call.
Each Dexto tool’s listing names its level in _meta (dexto/level): read, tidy, work,
act, approve or money. Dexto can’t ask you anything over an MCP connection, so your client
asks for it:
act: other changes in your Dexto. Your client should ask you before it calls the tool.approve: publishing, deploying, installing, or messaging and answering for you. money:
spending. The call must also carry confirm: true, which your client sends only after you agreed
to that exact call. Without it, Dexto refuses the call and nothing runs.Where a tool’s actions differ, each action has its own level (dexto/action_levels), and
dexto_apps_action takes the level of the App action it runs.
When Dexto refuses a call, the error’s data says why: its kind (such as forbidden,
needs_confirmation or not_found), and the missing scope or the call’s level where they
apply.
Some tool families are available only with the corresponding OAuth scope or platform policy. For example, managed GPU tools appear only when that capability is available to the connected organization. The server rechecks authorization when a tool is called; a tool listing is not a permanent grant.
dexto_computer_* refers to bounded shell and file operations in the connected workspace.
Managed GUI computers are a separate visual service exposed through the normal capability tools.
Search for GUI computers, then describe or call dexto.gui.gui_computer or
dexto.gui.gui_computer_control. They are available to ordinary organizations when the hosted GUI
provider and an owned Desktop context are available; they are not sandbox or GPU operations.
A client such as the Dexto CLI builds its commands from the server at runtime instead of a fixed list. These are what it reads, and they are the public contract of the Dexto MCP.
https://app.dexto.ai/mcp, JSON-RPC over HTTP POST with a bearer token./.well-known/oauth-protected-resource/mcp names the authorization server, whose
/.well-known/oauth-authorization-server metadata gives its endpoints. Clients are public: they
register themselves, use PKCE (S256), and can sign in without a browser on the same machine
with the device grant.scopes_supported is what a client asks for to
use the workspace. Its dexto_app_scopes maps each app or service, then each tool or App action,
to the scopes it takes, so a client that signed in for less can ask for one it can’t see yet.
Where a tool has conditional scopes, this list contains the scopes for all of those calls; use
its dexto/conditional_scopes metadata to select the scopes for the intended call.
Operations that can spend are left out of both, and billing:write and gpu:write are granted
only when a client names them. Two exceptions remain: computers:write (starts a chat’s computer
as metered compute) and capabilities:call (runs available capabilities, which can be paid) are
still in scopes_supported, and a sign-in that follows the MCP challenge asks for them.tools/list lists the tools the connection’s scopes reach. Each tool’s _meta has:
dexto/app and dexto/app_kind (app or service): the app that provides it, so a client
can group tools by app.dexto/level: read, tidy, work, act, approve or money, as in
Asking you first.dexto/action_levels, where a tool’s action input picks what it does: each action’s own
level, which replaces the tool’s for that call.dexto/conditional_scopes, when present: scope and when pairs for calls that need
additional access. Other calls to that tool can be available without those scopes.dexto_apps_list lists the installed Apps and their actions, dexto_app_get
describes one App’s actions, and dexto_apps_action runs one.data has its kind, and the missing scope or the call’s
level where they apply, so a client can sign in for the scope or ask the person and retry with
confirm: true.The catalog lists every tool and App action with its level and scopes.
Dexto adds tools, App actions, levels and _meta keys as it grows; a client ignores what it does
not know and treats an unknown level as act. A tool’s name, its _meta keys and the meaning of
each level do not change once published; a tool that goes away is first marked deprecated in its
description.