Connect via MCP

Connect Claude, Cursor or another AI app to your project, so it can build the scene for you. This page shows how to connect, how to sign in and how to choose what the app may do.

MCP (Model Context Protocol) is a standard way for AI apps to use outside tools. Once connected, your app can read the scene, add objects, set up events, write patches and check its own work.

Before you start

You need the address of the AR Clip MCP server:

https://editor.arclip.design/api/mcp/v1

It uses MCP over streamable HTTP. Any app that supports this can connect: claude.ai, Claude Desktop, Claude Code, Cursor and more.

There are two ways to sign in:

• In the browser — most apps. You only need the address. See Sign in in the browser.
• With a token — for apps without browser sign-in, for scripts and for CI. See Sign in with a token.

Working in a folder with a coding agent? Use the command line

arclip link sets up a folder for Claude Code in one step. It adds the MCP server for that folder, ties it to one project, and does not write a token into any file. For Codex, Cursor or OpenCode, arclip skill install --mcp adds the server to their settings. See Command line.

Only want the assistant to read the docs?

Connect the docs MCP server instead. It searches and reads these docs, with no sign-in.

Connect your app

claude.ai or Claude Desktop

1. Open Settings → Connectors.
2. Click Add custom connector.
3. Paste the address.
4. Sign in when asked. Your browser opens the permission page — see Sign in in the browser.

Claude Code

1. Add the server:

   claude mcp add --transport http arclip https://editor.arclip.design/api/mcp/v1

2. Start Claude Code and run /mcp.

3. Choose to authenticate. Your browser opens the permission page — see Sign in in the browser.

Cursor

1. Open .cursor/mcp.json to connect one project, or ~/.cursor/mcp.json to connect every project. Create the file if it does not exist.

2. Add the server:

   {
     "mcpServers": {
       "arclip": { "url": "https://editor.arclip.design/api/mcp/v1" }
     }
   }

3. The first time Cursor connects, your browser opens the permission page — see Sign in in the browser.

An app that only runs local servers

Some apps can only start MCP servers on your computer. Connect them through mcp-remote with a token.

1. Create a token — see Sign in with a token.

2. Add this to the app's MCP settings, with your token in place of <your-api-token>:

   {
     "mcpServers": {
       "arclip": {
         "command": "npx",
         "args": [
           "-y", "mcp-remote",
           "https://editor.arclip.design/api/mcp/v1",
           "--header", "Authorization:Bearer <your-api-token>"
         ]
       }
     }
   }

Check that it works

1. Open your project in the editor.
2. Ask your assistant to list the objects in that project's scene.
3. It answers with the same objects you see in the editor.

Sign in in the browser

This needs nothing from you in advance.

1. Connect your app with the address. The first time it connects, your browser opens a page in your AR Clip account. It lists the permissions the app asks for.
2. Untick anything you do not want to allow.
3. Press Allow. The app gets a token with exactly those permissions.

To see or revoke tokens later, open your account and go to API & MCP.

Sign in with a token

Use a token for apps without browser sign-in, for scripts and for CI.

1. Open your AR Clip account and go to API & MCP.

2. Create a token and choose its permissions.

3. Copy the token. It is shown only once.

4. Give it to your app. The app sends it in this header:

   Authorization: Bearer <your-api-token>

Keep your token secret

A token can change your projects. Treat it like a password: never share it, and revoke it in API & MCP if it leaks.

Permissions

A token can do only what you allow:

Permission	What it allows
editor:read	reading projects, scenes, resources and the AI balance
editor:write	creating, changing and deleting objects, components and settings
editor:ai	the generation tools — they spend your organization's AI credits
editor:publish	publishing, which makes the project public
editor:plugins	writing editor plugins and adding them to a project

Permissions apply everywhere the token works. A token without editor:write cannot change a scene in any way.

Only need analysis? Give a read-only token. An assistant that cannot write cannot break anything. Many useful jobs need nothing more: checking a scene, explaining why something does not fire, planning changes.

Plugins run for everyone

A plugin's code runs in the editor of everyone who opens the project it is added to. Its runtime code also runs for everyone who opens the published project. Allow editor:plugins only for an app you trust with that.

Your plan matters too. On Free, an app can read and check projects. Building, generation and publishing need a paid plan.

Work on one project

A session remembers its project and scene, so you do not have to repeat them in every request. An assistant switches project with set_active_project.

To tie a connection to one project for good, add the project to the address:

https://editor.arclip.design/api/mcp/v1?projectId=<project-id>&pin=1

A pinned session cannot move to another project. It also does not change the "last project" that your other apps pick up. The command line always connects this way.

The project id is the last part of the editor address: editor.arclip.design/project/<project-id>.

Watch it work

Changes the assistant makes appear in your editor right away, like a colleague's changes. They go into the edit history like any other edit.

Keep the editor open while you ask for changes, and watch them happen. You see at once when something is not what you meant, instead of finding out later.

What the assistant can do

Area	The assistant can
Scene	list, create, move, parent, duplicate and delete objects
Components	read and set any component on any object
Events	list triggers and steps, add and edit events
Patches	read, write and check node graphs, and show them as code
Animation	create timeline presets
Physics	set bodies, colliders and starting velocity
Resources	browse the project's resource tree, create folders, import and generate assets
Interface	read and write UI cards
Plugins	write plugins, add them to the project, and run the commands plugins offer
Publishing	publish, if the token allows it

It can also check its own work:

Check	What it does
Verify	finds problems that save without errors but break in the player: missing files, zero-scale objects, unknown events, steps aimed at deleted objects, a dark or fully hidden scene
Render	render_scene draws a picture of the scene — no editor needed
Screenshots	captures the viewport of an open editor
Measurement	gets an object's real size in metres, to check scale
Playtest	runs the scripts and physics, and presses every control it finds
Flows	run_flows plays scripted test scenarios and checks the results — the same as arclip test

Two more tools work outside AR Clip:

• Scene export saves a scene as data.
• Blender bridge works with a running Blender: list its objects, send a scene to it, or bring one back.

What the checks cannot tell you

render_scene shows layout, scale, colours and textures. It does not draw scripts, UI cards or effects. For playtest and flows, keep the project open in an editor tab. No check can tell whether a marker tracks in a real room — for that, use a phone.

If the assistant makes up names

list_component_schemas, list_event_types, list_patch_nodes and the describe_*_api tools show exactly what exists. If an assistant invents component names, tell it to call these first.

Ready-made prompts

The server offers a few prompts. Your app shows them as commands:

Prompt	What it does
build-scene	builds a scene from a description
add-interactivity	sets up taps, triggers and steps
animate	puts together a timeline
audit-scene	looks for problems
prepare-publish	checks what is worth checking before you publish

---

Next: Command line — let a coding agent build your project from a folder.