Huxly

Build, preview, and test real Expo, Flutter, and SwiftUI mobile apps from your AI client.

Documentation

Connect Claude Code, Cursor, Windsurf, ChatGPT, Codex, or Antigravity directly to your Huxly projects. Build with your own AI subscription.

Huxly AI Connector

The AI Connector lets you point your existing AI tools — Claude Code, Cursor, Windsurf, ChatGPT, Codex, Antigravity — directly at your Huxly projects. Your AI reads real files, pushes edits, starts the sandbox, watches the build, and hands you a live preview link. All inference runs on your own subscription. Huxly only provides the infrastructure.

Plan requirement: AI Connector is available on Developer, Business, and Max plans. Free users can generate an API key after upgrading at huxly.app/pricing.

Pair it with the Supabase MCP

Huxly's connector handles your app files, your backend, and deploys. It deliberately never reads your database.

Add Supabase's own MCP server alongside it and your AI gets both: it reads your real schema from Supabase while writing matching code through Huxly. Useful when building a backend, since it can see which tables already exist instead of inferring from migration files.

Both run at once — point your tool at Huxly's endpoint and Supabase's, and the AI picks whichever it needs.

How it works

MCP-compatible tools (Claude Code CLI, Claude.ai, Cursor, Windsurf, Cline, Zed, Warp, Antigravity) use the Model Context Protocol (MCP) — JSON-RPC over HTTP. Point them at https://huxly.app/api/mcp.
OpenAI tools — Codex and ChatGPT (Developer mode plugins) — use a stricter Streamable-HTTP transport. Point them at the dedicated https://huxly.app/api/mcp/stream endpoint instead, with the API key as a ?key= query parameter (see their sections below).

Step 1 — Get your API key

Open Huxly Settings
Open the MCP tab
Click Generate API Key
Copy the key — it's shown once

Keep this key private. It has full access to all your Huxly projects.

Setup by tool

Claude.ai (browser)

Go to claude.ai → Settings → Integrations
Add a new MCP server:
- URL: https://huxly.app/api/mcp
  - Authorization: Bearer YOUR_API_KEY
Save and start a new conversation — Claude will list available Huxly tools automatically

Claude Code CLI

Add to your ~/.claude/claude_desktop_config.json (or claude_code_config.json):

{
  "mcpServers": {
    "huxly": {
      "type": "http",
      "url": "https://huxly.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Restart Claude Code. Run /mcp to verify the server connected.

Cursor

Open Cursor Settings → MCP
Click Add MCP Server
Set type to HTTP and paste:

{
  "huxly": {
    "type": "http",
    "url": "https://huxly.app/api/mcp",
    "headers": {
      "Authorization": "Bearer YOUR_API_KEY"
    }
  }
}

Windsurf

In your Windsurf config file (~/.codeium/windsurf/mcp_settings.json):

{
  "mcpServers": {
    "huxly": {
      "serverUrl": "https://huxly.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Antigravity (Google AI Editor)

In ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "huxly": {
      "serverUrl": "https://huxly.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Codex (OpenAI)

Codex is OpenAI's agentic coding tool — the GPT-family equivalent of Claude Code. Its MCP transport is stricter than other clients, so it uses Huxly's dedicated Streamable HTTP endpoint: https://huxly.app/api/mcp/stream (note the /stream).

In the Codex app:

Open Codex → Settings → MCP → Add server
Choose Streamable HTTP as the server type, and name it huxly
Set the URL to (your key goes in the URL — leave bearer token and headers empty):

https://huxly.app/api/mcp/stream?key=YOUR_API_KEY

Save, then start a new conversation — run /mcp to confirm the Huxly tools loaded

In the Codex CLI (~/.codex/config.toml):

[mcp_servers.huxly]
url = "https://huxly.app/api/mcp/stream?key=YOUR_API_KEY"

Restart Codex and run /mcp to verify. If you see Transport channel closed, double-check you're on the /stream URL.

ChatGPT (Plus and above)

ChatGPT can build in Huxly directly — no Codex needed. Custom plugins live behind Developer mode, and like Codex they use the strict Streamable HTTP endpoint: https://huxly.app/api/mcp/stream (note the /stream).

Open ChatGPT → Settings → Security and turn on Developer mode
Go to the Plugins tab in the sidebar → click + to open the New Plugin dialog
Set Name to Huxly
Leave Connection on Server URL and paste (your key goes in the URL):

https://huxly.app/api/mcp/stream?key=YOUR_API_KEY

Set Authentication to No Auth — the key in the URL is what authenticates you
Tick I understand and want to continue, then click Create

Start a new chat and ask it to list your Huxly projects to confirm the tools loaded.

Why No Auth? ChatGPT's plugin dialog doesn't send a custom Authorization header, so Huxly accepts the API key as a ?key= query parameter instead. It carries exactly the same access as a bearer token — treat the whole URL as a secret.

What your AI can do

Tool	What it does
`list_projects`	List all your Huxly projects with framework and creation date
`list_files`	Get the full file tree for a project
`read_file`	Read any file in a project
`search_files`	Search across all files for a string or pattern
`write_file`	Create or fully replace a file
`write_files`	Create or replace multiple files in one call
`edit_file`	Make a surgical change — find exact text and replace it
`delete_file`	Delete a file
`create_project`	Create a new project (Expo, Flutter, or SwiftUI)
`start_sandbox`	Start the live preview sandbox for a project
`update_sandbox`	Push all current files to the running sandbox and wait for rebuild
`get_build_logs`	Get the current build status and any error output
`get_runtime_logs`	Get runtime logs from the running app
`get_project_url`	Get the Huxly dashboard URL for a project
`get_conventions`	Get coding conventions for a project's framework
`get_figma_design`	Pull design data from a connected Figma file
`get_preview_screenshot`	Take a screenshot of the live preview
`exec_in_sandbox`	Run a shell command inside the project sandbox

Typical workflow

Your AI can run this loop autonomously once connected:

list_projects → pick the target project
list_files → understand the structure
read_file on relevant files → understand the current code
write_file / edit_file → make the changes
update_sandbox → push and rebuild (returns the build log inline)
If build fails → read the log, fix, push again
get_project_url → return the preview link to you

You watch. The AI ships.

FAQ

Does this use my Huxly credits?

No. All AI inference happens on your own AI subscription (Claude, Cursor, ChatGPT, Codex, etc.). Huxly only provides the file storage, build pipeline, and sandbox — which are covered by your Huxly plan. Zero Huxly credits consumed per message.

What if I'm on the free plan?

The AI Connector is available on the Developer, Business, and Max plans — see huxly.app/pricing. Free users see an upgrade prompt in Settings.

Can I connect multiple AI tools at once?

Yes. Generate separate API keys for each tool in Settings. Each key is independent — revoking one doesn't affect the others.

Is my code safe?

Your API key grants full read/write access to all your Huxly projects. Treat it like a password — don't share it, don't commit it to git. You can revoke any key at any time from Settings.

What MCP protocol version does Huxly use?

2024-11-05. Compatible with all current MCP clients.

What if my AI tool isn't listed?

Any tool that supports the MCP HTTP transport works with Huxly — use the same url and Authorization: Bearer config. For strict clients like Codex and ChatGPT, use the /api/mcp/stream endpoint instead, with ?key=YOUR_API_KEY on the URL.