Integration · bring your workflow into a real app
Build an app instead of an n8n workflow
Coming from n8n? Describe the outcome and bychat builds a real app that owns its own logic — no canvas of nodes to wire, host, and babysit.
In n8n you draw the flow: a trigger, a chain of nodes, a credential per service, and the glue that moves data between them. It works, but the logic lives across a canvas you have to host, version, and keep alive — and there's no real UI for the people who actually use the result.
bychat flips that. You describe the outcome — "when a form comes in, enrich it, score it, and post the good ones to Slack with a dashboard I can browse" — and you get a whole app that holds that logic itself: a real GitHub repo, a live preview, screens a person can open, and the CI/CD and per-branch config already wired. The credentials your n8n nodes needed become environment variables on the app.
How it works
Describe the app
Say what the flow should accomplish in plain language. bychat scaffolds a real app — UI and logic — instead of a node graph.
Set up env vars
Bring the same API keys and webhook URLs your n8n credentials held. Add them as per-branch environment variables and the build reads them.
Link it up
Point the app at the services that matter, preview it live, share a branch URL, and publish when it's right — all in the same chat thread.
Set up your environment variables
Your flow already runs on credentials — an API key, a webhook URL, a model name, a rate limit. In bychat those live as environment variables on your app, per branch, so the same app can point at a sandbox key on one branch and a production key on another without touching anyone else's. Set them once and the build picks them up; change one on a branch and only that branch rebuilds with it.
- Add a secret (API key, token, connection string) as an environment variable — it stays server-side and never ships to the browser.
- Vars are per-branch: a different key, model, or feature flag on a branch builds and runs in isolation, so trying a version stops being a meeting.
- Reference them in chat by name — "use the OPENAI_API_KEY env var for the model call" — and the agent wires the code to read them.
Example prompts
Copy one to start, or write your own — bychat takes it from there.
Rebuild my n8n lead-routing flow as an app: take a webhook of new signups, enrich each with the Clearbit API, score them, and show a sortable dashboard of the hot ones.
I have an n8n flow that posts new Stripe payments to Slack. Make it a small app with a payments table, filters, and a 'resend to Slack' button — use the STRIPE_API_KEY and SLACK_WEBHOOK_URL env vars.
Turn my nightly n8n sync into an app: pull from the Airtable API, transform the rows, and let me browse, search, and export the result. Read AIRTABLE_TOKEN from the environment.
Replace an n8n webhook-to-email flow with an app that has a real inbox view, templates, and a send log. Use SENDGRID_API_KEY as an env var.
Frequently asked questions
Is bychat an n8n alternative?
For a lot of flows, yes. If your n8n workflow exists to move data between services and surface a result, bychat can build that as a real app — with a UI, CI/CD, and per-branch config — instead of a node graph you host and babysit. For pure background automation with no user-facing surface, a workflow tool may still fit; bychat shines when there's an app a person actually opens.
What happens to my API keys and credentials?
They become environment variables on your app. Add a secret once and it stays server-side — it's never shipped to the browser — and you can scope different keys to different branches, so a sandbox key on one branch and a production key on another never collide.
Do I have to recreate the whole flow by hand?
No. You describe what the flow should accomplish and the agent writes the code. You can paste your n8n nodes' intent or even a description of the steps, name the env vars the credentials map to, and iterate in chat until it matches.
Can I still call the same services n8n called?
Yes. Anything reachable by an HTTP API or webhook — the same endpoints your n8n nodes hit — the app can call. You wire the calls by describing them in chat and pointing the app at the right env vars.