Quick Start Guide

Build your first API in under 5 minutes. No infrastructure required.

1 Create Your First Block

Open the Dashboard and click anywhere on the canvas to create a new block.

Select "Process" as the block type to write JavaScript code.

// Example: Transform input data
const data = input;
return {
    message: "Hello from Qu4zr!",
    timestamp: new Date().toISOString(),
    received: data
};
            

2 Test Your Block

Click the Run button in the execution panel to test your block.

The output will appear in the "Final Flow Output" editor below.

Tip: Use console.log() in your code for debugging. Logs appear in the execution logs viewer.

3 Deploy as an Endpoint

Change the block type to "Endpoint" in the bottom panel.

Configure your endpoint:

Create a Domain (e.g., "my-api")
Set the Path (e.g., "/hello")
Select allowed HTTP Methods (GET, POST, etc.)

Your API is now live at:

https://api.qu4zr.io/my-api/hello

4 Call Your API

Generate an API key from the Domain settings, then call your endpoint:

curl -X GET "https://api.qu4zr.io/my-api/hello" \
     -H "Authorization: Bearer YOUR_API_KEY"
            

Or use the query parameter method:

curl "https://api.qu4zr.io/my-api/hello?code=YOUR_API_KEY"

Block Types

Process - Write JavaScript to transform data. Has access to input from connected blocks.
Raw Data - Store static JSON or text data. Useful for configuration or test data.
Endpoint - Expose a block over HTTP, as an API reply or a published page. Read the request through the request global: request.body, request.query, request.method, request.headers, request.params.
SignalR - Run C# logic on your own machine or network (internal DBs, local files) via a small runner that connects outbound — no VPN, no inbound ports. Secrets stay on your machine.

Connecting Blocks

Create data flows by linking blocks together:

Select a block and click the Link button in the floating toolbar
Click on the target block to create a connection
The output of the source block becomes the input of the target block

Tip: When multiple blocks connect to one target, their outputs are merged into a single input object.

The one that catches everybody: an Endpoint block emits its own raw data, not the request — so the first Process block after one receives null, not the body. Read the request through request, which every block downstream can see.

SignalR Remote Execution

Run C# logic on your own servers while designing in the cloud — the runner connects outbound, so there's no VPN and no inbound firewall rule:

Add a SignalR block and write its handler in C# — or just describe it to the AI assistant, which authors it for you
Download the runner (the handler is baked in) — or let the assistant download, build and launch it for you with one command
Review Handler.cs, add any connection strings to appsettings.json under "Local" (they never leave your machine), and run it
The block executes locally and logs stream back to your dashboard. Run with --test and the assistant can verify the handler on your machine and iterate until it's green
Keep it always-on: install the runner as a Windows service / systemd unit so your endpoint survives reboots (needs an admin / sudo approval)

Perfect for accessing internal databases, legacy systems, or compliance-sensitive data.

Drive qu4zr from your own AI assistant (MCP)

Everything the in-app assistant can do, your own assistant can do too. qu4zr-mcp is an MCP server that exposes the Management API as tools: create workspaces, write and patch blocks and code files, test, provision domains and vaults, schedule, deploy, read logs. What it builds shows up on your canvas as an ordinary, fully editable workspace.

Create an API client under Account → API & AI Access and copy the secret — it is shown once.
Register the server with your client. That page prints the exact command or config file for each one, with your client id already filled in.
Ask for something: “create a workspace called Orders with an endpoint at /orders that returns the request body”.

The commands, for macOS and Linux clients that have one:

claude mcp add qu4zr -s user --env QU4ZR_CLIENT_ID=igdc_… --env QU4ZR_CLIENT_SECRET=igds_… -- npx -y qu4zr-mcp
copilot mcp add qu4zr --env QU4ZR_CLIENT_ID=igdc_… --env QU4ZR_CLIENT_SECRET=igds_… -- npx -y qu4zr-mcp
codex mcp add qu4zr --env QU4ZR_CLIENT_ID=igdc_… --env QU4ZR_CLIENT_SECRET=igds_… -- npx -y qu4zr-mcp
agy mcp add --env QU4ZR_CLIENT_ID=igdc_… --env QU4ZR_CLIENT_SECRET=igds_… qu4zr npx -y qu4zr-mcp
        

Codex on Windows needs a direct Node launcher. This command stages it and writes the TOML:

npx -y qu4zr-mcp install codex --windows --client-id igdc_… --client-secret igds_…
        

Run it on the Windows machine where Codex runs. The generated TOML pins that machine’s Node executable and stable runtime path, and automatically uses the Windows trusted certificate store when that Node version supports it.

For the ones configured by file — Cursor, Claude Desktop, VS Code, Kiro, Windsurf — the package writes it for you, in that client’s shape and in that client’s file:

npx -y qu4zr-mcp install cursor        # or claude-desktop, vscode, kiro, windsurf, codex
npx -y qu4zr-mcp install vscode --project
npx -y qu4zr-mcp install kiro --print  # print the snippet, touch nothing
        

The clients disagree, and they disagree silently. VS Code’s .vscode/mcp.json names the root key servers (not mcpServers) and needs "type": "stdio"; Codex stores TOML under [mcp_servers.qu4zr]. An entry in the wrong shape saves cleanly, loads nothing, and reports nothing — which looks exactly like a broken server.

Codex + Windows: don’t replace the installer command with codex mcp add … -- npx or cmd /c npx. Codex can send initialize while npm still owns stdin and report a 30-second timeout before qu4zr starts. The installer removes npm from the MCP process chain and enables Windows’ trusted certificates for Node HTTPS when supported.

Windows certificates: every generated Windows configuration sets NODE_USE_SYSTEM_CA=1. Recent Node versions then trust the same antivirus, VPN and corporate-proxy roots as Windows; older Node versions safely ignore the variable.

Nothing happening? npx qu4zr-mcp doctor runs the same three steps the server runs — read the config, get a token, make one real API call — in your terminal, and names the one that failed. The usual answer is that the credentials are set in your shell rather than in the MCP config’s own env block, where the spawned process can see them.

Deletes, deploys and runs won’t act until the assistant calls them again with confirm: true, so you always see what is about to happen; your MCP client asks for approval on top of that. To make an assistant build-only, give its API client just flows:read and flows:write.

Keyboard Shortcuts

V - Pointer tool (select and move blocks)
M - Selection tool (marquee select multiple blocks)
H - Hand tool (pan the canvas)
A - Add block tool
R - Reset grid view
Ctrl+F - Search blocks
Mouse wheel - Zoom in/out

Ready to build?

Create Free Account