Import from Other Tools

Bring existing work into Circuitry — automations, notebooks, whiteboards, and designs.

Circuitry converts files exported from other tools into native Circuitry documents. Open File → Import…, pick a file (or paste a Figma link), review the conversion report, and the result opens as a regular tab you can edit and run.

How to import

1. Open File → Import….
2. The dialog lists formats matching your current editor first (workflow formats while a workflow is open, and so on), with everything else under Other formats.
3. Drop a file onto the dialog or click to pick one. The format is detected automatically — useful when several tools share the .json extension.
4. For Figma, select Figma file, then paste the file's URL and a personal access token (created in your Figma account settings under Security).
5. Review the import report, then click Open — or Open & Resolve to convert unmapped steps right away (see Resolving placeholders below).

Supported formats

The import report

Imports are best-effort conversions, and the report tells you exactly how yours went. After converting, entries are grouped by severity:

• Errors — something could not be converted at all.
• Placeholders — steps that have no Circuitry equivalent yet (see below).
• Warnings — things that converted but need review: expressions left as-is, conditions that were simplified, schedules that fell back to a default.
• Info — notes worth knowing, such as a webhook receiving a fresh URL.

If the report is empty, everything mapped cleanly.

Placeholder nodes

Steps Circuitry can't translate become clearly marked placeholder nodes. A placeholder:

• keeps its original name, position, and connections, so the shape of your flow is preserved;
• keeps all of the original step's settings in its configuration, so nothing is lost;
• does not execute — resolve it (below) or replace it by hand when you're ready.

Resolving placeholders

Circuitry can convert placeholders into working nodes for you, two ways:

• Match an integration — when the original step targets a service in Circuitry's Integrations Gallery (Slack, Google Sheets, Stripe, …), one click swaps the placeholder for the matching operation, pre-filling settings whose names line up. The node keeps its position and connections.
• AI fix — for everything else, an AI pass reads the original step's settings and its neighbours in the flow, then rebuilds it as the closest Circuitry node. You choose the model — any model from your model picker works, including local models and CLI models, so resolution can run entirely on your machine.

Open the resolver from Open & Resolve right after an import, or right-click any placeholder and choose Resolve Placeholder…. Resolve all works through every placeholder at once: confident integration matches first, AI for the rest.

Every resolved node is flagged for review — open it and check its settings before running the flow. Anything the resolver can't faithfully convert stays a placeholder, with the reason shown.

Reconnecting services

Credentials never travel inside export files — no tool includes your Slack tokens or database passwords in an export. After importing, the report lists which service connections need to be re-established. Set them up through Circuitry's Integrations Gallery connections, environment variables, or node settings, depending on the step.

Imported webhooks always get a fresh Circuitry webhook URL — the original tool's URL does not carry over, so update anything that calls it. See Webhooks.

What to expect, format by format

n8n

Carries over: nodes, connections, and canvas positions; HTTP Request, Set, Code, IF, Merge, webhook and schedule triggers, and notes map to native Circuitry nodes. AI Agent and LLM Chain nodes map to Circuitry's Agent node, folding directly-attached model settings into the agent's configuration.

Check after import:

• Switch, Filter, Wait, and all service nodes (Slack, Gmail, etc.) become placeholders — rebuild them with Circuitry's condition/code nodes or plugin operations.
• Expressions that reference other nodes by name are rewritten only when the referenced node feeds directly into the node using the expression. References to more distant nodes are left verbatim and flagged.
• Function-style expressions ($now, date formatting chains, arithmetic, method calls) pass through unchanged with a warning — they won't evaluate until you rewrite them.
• Per-item execution differs. n8n runs each node once per item; Circuitry runs each node once. Converted Set and Code steps assume a single object input, and n8n Code-node APIs ($input, $json, items) are kept verbatim and flagged for review.
• Merge becomes a Join that waits for all branches; n8n's other merge modes (combine, choose branch, multiplex) are noted in the report but not reproduced.
• IF covers the common operators; conditions that can't be translated default to true with a warning.
• Schedules translate cron expressions and minute/hour/day intervals; anything else falls back to hourly with a warning.
• AI tool, memory, and parser sub-nodes become placeholders attached with reference-only connections (they don't execute) — re-wire tools through plugins or MCP, and note that chat history is built into Circuitry agents.
• Environment references become {{env.X}}, which works in URLs and headers but is not automatically available inside Code or Condition nodes.

Make

Carries over: modules, routes, and positions. Webhook triggers become webhook Start nodes, webhook responses become Webhook Response nodes, HTTP modules become Action nodes, JSON parsing and Set Variable(s) become Code nodes, and Routers become Fork nodes.

Check after import:

• All other modules (app integrations) become placeholders.
• Mapper references to the immediately previous module are rewritten to Circuitry templates; references to earlier modules are left verbatim with a warning. Make functions inside {{...}} (formatDate and friends) are not translated.
• Non-webhook triggers get a plain Start node in front of them; scenario-level scheduling settings are not converted — re-create the schedule on the Start node.
• Per-module error-handler routes are not imported (a warning is emitted). Filter operators outside the common set default to true with a warning.

Node-RED

Carries over: each tab becomes its own workflow document; nodes, wires, and relative layout are preserved (spacing is widened slightly to fit Circuitry's larger nodes). Inject, function, switch, HTTP, and debug-style nodes map to native equivalents; same-tab link pairs become direct connections.

Check after import:

• Function nodes run inside a compatibility wrapper that emulates the msg object; flow/global context is unavailable and some globals (timers, for example) are blocked in Circuitry's code sandbox — flagged bodies may need editing.
• Switch with "checking all rules" collapses to a first-match condition chain (warning); multi-output function nodes flatten to a single output.
• Inject payload/topic values are not carried, and interval repeats become a manual Start (cron schedules do map).
• Configuration nodes and subflow definitions are skipped with report entries; subflow instances and link nodes import as placeholders, and links between tabs can't be bridged.

Langflow

Carries over: components, edges, and layout. Agents and LLM chains map to the Agent node, and a directly-wired model component folds into the agent's model setting.

Check after import:

• Tools become non-executing placeholders (wiring preserved) — Circuitry agent tools come from MCP and plugin wiring, so reconnect them there.
• Memory components are dropped (chat history is built into Circuitry agents); this is reported as info.
• Vector stores map to a Circuitry vector store node with no store selected — open its settings, pick or create a store, and re-ingest your documents in the Knowledge Base.
• Document loaders, text splitters, embeddings, and output parsers become placeholders — redo ingestion in the vector store editor.
• Prompt {variables} are carried verbatim into prompts with a warning; rewrite them as Circuitry template variables.

Flowise

Same expectations as Langflow (tools, memory, vector stores, prompts), plus:

• Classic chatflow exports are supported; AgentFlow v2 exports are not yet.
• The model name carries into the agent; provider-specific extras (top-p, max tokens, penalties) are not carried.

Excalidraw

A scene becomes a notepad drawing — shapes, freehand strokes, arrows, and text.

Jupyter notebooks

Cells become a CodeBook: code cells, markdown text cells, and a shared kernel language.

SVG

The image becomes an editable Designer screen — shapes, paths, text, and images.

Figma

Frames become Designer screens — shapes, vectors, text, and images. Image fills that can't be fetched appear as grey placeholders (noted in the report). Figma's API applies its own rate limits, especially on free plans — if an import fails or stalls, wait a little and try again.

A note on fidelity

Different tools have genuinely different execution models, so a converted flow is a strong head start, not a guaranteed drop-in. The report is honest about what needs attention: work through the placeholder and warning entries, reconnect your services, run the flow, and you're migrated.

Related

• Building Workflows
• Integrations Gallery
• Webhooks
• For Jupyter Users
• Designer
• Template Variables