Help & documentation

01Core concepts

Flowroid automations are called flows. A flow is three parts that run in sequence. That is what a flow is; how you assemble one is two builders, and both produce this same shape.

1. Starts on

   Triggers

   A device event starts the flow — a notification arrives, you reach a location, the battery drops. A flow can have one or more.

2. Guarded by

   Conditions

   Optional checks evaluated when a trigger fires. The flow only continues if they pass. An empty group passes.

3. Then runs

   Actions

   What the flow does, in order. Each action can read the output of the ones before it. Every run is logged to history.

Flows are event-driven — they react to events rather than polling — and fail gracefully: if one action errors, the flow logs it and either continues, retries, or stops based on your settings, but never crashes the app.

On the canvas each of those parts is a node, and the order is the wire you draw between them. Conditions appear either as a guard on the whole flow or as a branch mid-run; loops and sub-flows are nodes too. The vocabulary is the same everywhere in the app — the trigger → conditions → actions line you see when the assistant proposes a flow is describing exactly this.

02Getting started

Install & first launch

1. Install Flowroid from Google Play and open it.
2. On first launch you're guided through the Permissions overview, where you grant only the permissions the features you want require.
3. Flowroid starts a persistent foreground service that keeps your automations alive. The small ongoing notification shows how many flows are active — that's what lets flows run when the app isn't open.

Create your first flow

There are three places to start, and the + button on the Flows screen holds two of them:

1. Templates — 63 ready-made automations. Pick one, adjust its times, places, apps and thresholds, install it. This is the fastest first flow, and what you install is an ordinary flow you can open and change. See Templates.
2. + → Blank canvas — the visual builder. An empty canvas that asks for a trigger first, then whatever should follow it.
3. + → Create with AI — describe the automation in a sentence and it drafts the flow for you to review. See Build with AI.

A flow you build yourself is saved switched on and runs the next time its trigger fires. A flow the AI drafts is saved switched off until you have read it and turned on Run automatically. Either way, the permissions the flow needs are named before it can do anything, and every run is recorded in the flow's execution history.

03Building flows

Flowroid has exactly two builders. You draw the flow on a canvas, or you describe it and read back what the assistant drafted. There is no third path and no wizard — installing a template drops you into the same canvas with the nodes already placed.

Both produce the same thing — one flow, made of the same triggers, conditions and actions, stored in the same place and run by the same on-device engine. A flow you drafted by asking is fully editable on the canvas, and a flow you drew by hand can be revised by asking. Nothing you build depends on AI to keep running.

Working on the canvas

Both builders end here, so it is worth knowing the surface. Nodes carry ports: a trigger has an output and no input, because it is where the flow starts; an action has one of each; a condition has a true port and a false port; a loop has a body port and a done port. Dragging a wire from a port onto empty canvas reopens the palette filtered to the node types that can legally connect to it, so a connection you can draw is a connection that will run.

Tapping a node opens its configuration form, generated from that trigger or action's own schema — you only ever see fields it actually has, and the form documents the {{previous.*}} outputs the node makes available to whatever comes after it. Saving is blocked while the flow is invalid, and the message names the node and the field rather than the fact; Fix jumps to it.

The toolbar carries the rest: undo and redo (labelled with the step they will reverse), fit-to-view, auto-arrange with a direction and spacing, a dot-or-line grid with snapping, copy / cut / paste, a minimap, and a test run that executes the flow once without waiting for its trigger. Leaving with unsaved changes asks first.

Build with AI, in detail

Create with AI is one-shot: you describe the automation, it asks a clarifying question if the request is genuinely ambiguous, and it comes back with the flow it means to build — the trigger, the conditions and the actions in order, plus a plain-language explanation. From there you can refine it in words, regenerate it, create it, or open it in the canvas and finish by hand.

The assistant can also draft a flow in the middle of a conversation. It returns the same review — the same pipeline, the same explanation — as a card in the transcript, so you can read and keep a flow without leaving the chat. Asking it to change a flow you already saved is handled as an update: it shows the new version, tells you the live flow has not changed, and applying it replaces the definition while keeping the flow's enabled state, its pin, and its run history.

Action chaining & outputs

Actions run sequentially. Every action produces structured outputs that later actions can reference using template expressions. For example, an HTTP Request action exposes statusCode, headers, body, and latency, which a following action reads with {{previous.http.body}}.

Control flow

First-class control-flow actions let a flow branch, loop, and call sub-flows:

• If / Else — run one set of nested actions or another based on a condition group.
• Loop — repeat nested actions forEach item, a fixed number of times, or while a condition holds (with a maxIterations safety cap).
• Call Sub-Flow — invoke another flow and pass it an input object, enabling reusable building blocks.
• Delay, Stop, Log, plus Math, String, and Array helpers for in-flow data manipulation.

Error handling

Each action can be configured to continue, stop, or retry on error. Failures are recorded in the flow's execution history with logs, so you can see exactly what happened and when.

04Trigger catalog

Flowroid ships 32 triggers. Permissions noted are only required if you use that trigger. Two of them are not device events at all: Webhook Received is something on your network calling the phone (§12), and Manual is you, from a Quick Settings tile, a launcher shortcut, a home-screen widget, a notification button, or the API.

05Action catalog

Flowroid ships 45+ actions. Each action's outputs are available to later actions via template expressions.

06Conditions

Conditions let a flow decide whether to proceed, or which branch to take in an If / Else. Each condition compares a left value (usually a template expression) against a right value using an operator.

Operators

Combining conditions

Conditions group into AND / OR sets, and groups can nest arbitrarily deep for complex logic. An empty condition group passes (evaluates to true).

AND
├── {{event.sender}} EQUALS "+15551234567"
└── OR
    ├── {{event.body}} CONTAINS "urgent"
    └── {{event.body}} CONTAINS "important"

07Variables & template expressions

Scopes

Template expressions

Anywhere a field accepts dynamic input, use {{ ... }} expressions with dot-notation and array indexing:

{{event.sender}}              Trigger event field
{{event.data.nested}}         Nested field
{{event.items[0]}}            Array index
{{global.counter}}            Global variable
{{flow.temp}}                 Flow-scoped variable
{{previous.http.body}}        Output of a previous action (by type)
{{prev[0].output.field}}      Output of a previous action (by index)
{{device.battery.level}}      Live device state
{{secret.api_key}}            Secret value (read-only)

Device variables

The device.* namespace exposes live state without needing a trigger:

• Battery — device.battery.level, .charging, .status
• Network — device.network.connected, .type, .wifi
• Screen — device.screen.brightness
• Android — device.android.version, .release
• Locale — device.locale.language, .country
• Time — device.time.zone, .timestamp

Referencing a category without a property (e.g. {{device.battery}}) returns the whole object as JSON.

Secrets

Secret variables are encrypted at rest using AES-256-GCM with a key held in the device's hardware-backed Keystore (where available). Secret values are masked everywhere in the UI, are never written to logs, and are read-only inside expressions — a flow can use {{secret.api_key}} but cannot overwrite it.

08Permissions

Flowroid only asks for the permissions needed by the features you actually use. They fall into two groups: standard runtime permissions (granted with a system dialog) and special-access permissions (granted on a dedicated Android settings screen).

Runtime permissions

Special-access permissions

These are granted through Android's settings, not a popup. Flowroid links you straight to the right screen. The Permissions screen shows everything at a glance, grouped by category, with grant status and one-tap actions; a Guided mode walks you through only the permissions that still need attention.

09Keeping automations running

Android aggressively stops background apps to save battery, and some manufacturers are far more aggressive than others. To make sure your flows run when you expect them to:

1. Exempt Flowroid from battery optimization. The single most important step. Settings → Apps → Flowroid → Battery → Unrestricted / Not optimized.
2. Enable auto-start on Xiaomi, Oppo / Realme, Vivo / iQOO, OnePlus, Huawei / Honor, Asus, and similar. These brands block apps from starting after a reboot unless you allow auto-start in their own settings. Flowroid provides a shortcut to the relevant manufacturer screen.
3. Grant notification access if you use notification triggers.
4. Grant exact-alarm access if you use schedules and want minute-accurate timing.

Boot behaviour

When your device restarts, Flowroid's boot receiver restarts the foreground service (if auto-start is enabled) and resumes all enabled flows. Boot triggers fire after you first unlock the device, once encrypted storage becomes available — Flowroid does not run during the locked, pre-unlock phase.

10Templates

Flowroid ships 63 ready-made templates spanning beginner to intermediate automations, including a set built around webhooks — the phone answering something else on your network. The Templates library is the shortest path to a first flow: pick one, adjust its times, places, apps and thresholds, and install it. It arrives as an ordinary flow on the same canvas, with nothing held back. A sampling of what's included:

• Silent at Night

  Go silent at bedtime on selected days.

• Low Battery Alert

  Notify when the battery drops below a threshold.

• Wi-Fi at Home

  Manage Wi-Fi on geofence arrival.

• Flip to Silence

  Silence the phone when placed face-down.

• Headphones Auto-Play

  Launch music and set volume when headphones connect.

• NFC Office Mode

  Tap a tag to switch to work mode.

• Auto Dark Mode at Sunset

  Schedule-based dark mode.

• Pocket Mode Protection

  Lock the screen when pocketed.

• Meeting Auto-Silence

  Silence during calendar events.

• Battery Overheat Warning

  Alert on high battery temperature.

• Auto TTS Notification Reader

  Read notifications aloud.

• Media Pause on Call

  Pause media on an incoming call, resume after.

• File Backup on Charge

  Back up a file when charging.

…and many more across power, connectivity, sensors, and productivity.

11Import & export

Every flow can be exported to a portable file and re-imported on the same or another device — handy for backups, sharing, or moving between devices. Import / export works entirely with local device storage: no account or cloud required. (Flows can also be exported and imported through the API server.)

12The embedded HTTP API server

Flowroid can run an embedded HTTP server directly on your device, turning your phone into an automation endpoint that external systems call. The device is the server — your computer, home-automation hub, or another phone connects to the phone.

Security model

The API server is off by default and built secure-by-default:

• Localhost-only by default. It binds to 127.0.0.1 and is unreachable from the network until you explicitly enable the Enable LAN access toggle (which rebinds to 0.0.0.0 and shows a clear warning).
• Authentication required. All protected routes require an API key or a JWT bearer token. The signing secret is stored in the hardware-backed Keystore; if that's unavailable the server refuses to start rather than fall back to a guessable secret.
• Scoped access. API keys carry fine-grained scopes (flows:read, flows:write, flows:execute, variables:read, webhooks:write) so you grant only what each integration needs.
• CORS closed by default. No browser origins are allowed unless you add them to an allow-list; wildcard origins are rejected.
• Request body cap of 1 MiB and configurable rate limiting.
• Secrets never leave in plaintext. Secret variables are returned masked; revealing a value requires a separate dedicated scope.
• SSRF protection on outbound HTTP actions (loopback, link-local, and private ranges are blocked by default).
• Optional HTTPS / TLS with a self-signed certificate you can export, and HMAC-SHA256 signature verification for inbound webhooks.

Authentication flow

Exchange an API key for a short-lived JWT, or authenticate per-request with the key directly (X-Api-Key: fd_live_xxxx).

# Exchange an API key for a short-lived JWT
curl -X POST http://<device-ip>:8080/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"apiKey":"fd_live_xxxxxxxxxxxxxxxx"}'
# → { "accessToken": "...", "refreshToken": "...", "expiresIn": 900 }

Core endpoints

All endpoints are versioned under /api/v1.

Run a flow remotely

curl -X POST http://<device-ip>:8080/api/v1/flows/<flow-id>/execute \
  -H "X-Api-Key: fd_live_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"input":{"reason":"manual run"},"sync":true}'

Inbound webhooks

Create a webhook bound to a flow, then trigger it from any external system. The webhook can require no auth, an API key, a bearer token, or an HMAC-SHA256 signature:

BODY='{"event":"deploy","status":"green"}'
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "your-secret" -hex | sed 's/^.* //')
curl -X POST http://<device-ip>:8080/api/v1/hooks/my-webhook \
  -H "Content-Type: application/json" \
  -H "X-Signature: sha256=$SIG" \
  -d "$BODY"

Live, interactive reference

The server publishes its own always-current OpenAPI spec and Swagger UI on the device: GET /openapi.json and /openapi.yaml for the machine-readable spec, GET /docs for interactive Swagger UI, and GET /redoc for the ReDoc viewer. Because these are generated from the running server, they are the authoritative, version-matched reference for your specific build.

13The AI assistant

Ask in plain language and the assistant runs your flows and Flowroid's own device actions, showing you each step as it goes. Anything that changes your device asks first, spelling out exactly what will run.

What it can do

• Run Flowroid's device actions — flashlight, ringer, brightness, volume, Wi-Fi, notifications, text-to-speech and the rest of the catalog in Actions.
• List and run your flows, make HTTP requests to servers you own, work with files, and read or write global variables.
• Draft a flow for you. Describe an automation and it returns a review card you can read and keep without leaving the conversation; once it has actually run something for you, Save as flow turns that session into a reusable automation. In both cases the flow is saved disabled for you to review before anything runs on its own. The drafting surfaces are covered in Build with AI.
• Ask you a clarifying question when your request is ambiguous.

You stay in control

• Confirmation before anything changes. An HTTP POST, a file write, a system intent, a device-state change — each pauses with a card showing exactly what will run. Allow it, deny it, or allow it for the session.
• Autonomous mode is optional and sits behind an explicit warning. Even then, blocked actions, your secret variables and the network safety blocklist still apply, and a bar shows it is on.
• Interrupted approvals fail closed. Close the app with a confirmation pending and that action is recorded as declined, never run later.
• Secrets stay secret. Secret variables are never readable by the assistant and are never sent with your message.

Talking to it

A microphone button sits next to the message box, and Flowroid can be set as your device's digital assistant so a long-press of the power button summons it. It is push-to-talk: there is no wake word and no background listening, and Flowroid never records or stores your audio. Speech is turned into text by your device's own recogniser.

Where it runs, and what leaves the phone

Answering a question needs a model, and the model is not on your phone. So when you send a message, that message and the conversation so far go to Flowroid's server and on to Google's Gemini API to be answered. We do not store it and we do not log it, and it is not used to train models. The Privacy Policy sets out the whole flow field by field.

Two parts of the assistant never leave the device at all: the learned shortcuts that make repeated commands run instantly with no AI call, and the suggestions Flowroid draws from your own usage.

Running your own model

Point Flowroid at a model you host — Ollama, LM Studio, or any OpenAI-compatible server — under Settings → AI → Advanced. Requests then go to your address and nowhere else. It is free and unmetered: it does not touch your credit allowance, and it keeps the assistant working at a zero balance.

14Plans & pricing

Flowroid is sold as one subscription that unlocks the whole app. There are no feature tiers and nothing is held back from a subscriber.

If you bought Flowroid before

AI credits

Credits are what the assistant spends when it answers you. Pro includes a monthly allowance; it resets each billing period and does not roll over. If you use the assistant heavily you can buy top-up packs — currently $2.99, $6.99 and $19.99 — and purchased credits do not expire. They are spent only once the monthly allowance is gone.

15Privacy & security

• Automation is on-device, always. Flows run entirely on your phone. No account requirement, no cloud relay for flow execution, and no connection needed.
• The routine call that leaves is anonymous. Flowroid checks your trial and subscription status with its licence server. That request carries a one-way hash of a device identifier, never the raw identifier and never anything from your flows.
• The assistant is the one feature that sends what you type. Use it and your message and its context go to our server and on to Google's Gemini API to be answered; we do not store or log it, and it is not used to train models. Never open it and nothing you type leaves the phone. See The AI assistant and the Privacy Policy.
• Sensitive data stays local. Notification titles and text are never written to Flowroid's logs. Secret variables are encrypted at rest with a hardware-backed key and masked throughout the UI.
• The API server is opt-in, localhost-bound, and authenticated. Network exposure requires an explicit toggle; all protected routes require scoped credentials; CORS is closed by default.
• Outbound requests are guarded. The HTTP action blocks server-side request forgery against loopback, link-local, and private address ranges by default.
• No restricted permissions. Flowroid does not request SMS, call-log, or accessibility-service permissions.
• Honest capability disclosures. Where Android or a manufacturer restricts a capability, the relevant template or action says so plainly in-app.

The full Privacy Policy details exactly what each permission accesses and where the data goes.

16Troubleshooting & FAQ

Still stuck? Reach the maker directly — Flowroid has no telemetry, so the detail you include is all support has to go on.

Back to top