# Flexie - Full Content

> Flexie is one platform shaped to your business: CRM, billing, support, forms, and automation, with an AI workforce that runs the busywork for you.

Generated from https://flexie.io. Page map followed by the full text of every public page.

## Page Map

| Page | URL | Markdown |
| --- | --- | --- |
| Flexie: All-in-One Business Platform Shaped to You, with AI | https://flexie.io/ | https://flexie.io/index.md |
| About Flexie | https://flexie.io/about | https://flexie.io/about.md |
| Flexie AI: An AI Workforce That Acts on Your Data | https://flexie.io/ai | https://flexie.io/ai.md |
| API Reference | Flexie REST API for Contacts, Deals, Cases & More | https://flexie.io/api | https://flexie.io/api.md |
| Workflow Automation | https://flexie.io/automation | https://flexie.io/automation.md |
| Compare Flexie | https://flexie.io/compare | https://flexie.io/compare.md |
| Contact Flexie | https://flexie.io/contact | https://flexie.io/contact.md |
| Cookie Policy | https://flexie.io/cookie-policy | https://flexie.io/cookie-policy.md |
| Data Retention Policy | https://flexie.io/data-retention-policy | https://flexie.io/data-retention-policy.md |
| FAQ | https://flexie.io/faq | https://flexie.io/faq.md |
| How Flexie Works | https://flexie.io/how | https://flexie.io/how.md |
| Imprint | https://flexie.io/imprint | https://flexie.io/imprint.md |
| Integrations & developer access | https://flexie.io/integrations | https://flexie.io/integrations.md |
| On-Premises Deployment | https://flexie.io/on-premises | https://flexie.io/on-premises.md |
| Platform | https://flexie.io/platform | https://flexie.io/platform.md |
| Pricing | Flexie: One All-In Platform, No Tiers, No Limits | https://flexie.io/pricing | https://flexie.io/pricing.md |
| Privacy Policy | https://flexie.io/privacy-policy | https://flexie.io/privacy-policy.md |
| Resources & Knowledge Base | https://flexie.io/resources | https://flexie.io/resources.md |
| Activity & oversight | https://flexie.io/resources/ai/activity-and-oversight | https://flexie.io/resources/ai/activity-and-oversight.md |
| AI in workflows | https://flexie.io/resources/ai/ai-in-workflows | https://flexie.io/resources/ai/ai-in-workflows.md |
| Approvals & safety | https://flexie.io/resources/ai/approvals-and-safety | https://flexie.io/resources/ai/approvals-and-safety.md |
| AI by text & WhatsApp | https://flexie.io/resources/ai/by-text-and-whatsapp | https://flexie.io/resources/ai/by-text-and-whatsapp.md |
| The chat assistant | https://flexie.io/resources/ai/chat-assistant | https://flexie.io/resources/ai/chat-assistant.md |
| Connecting outside assistants | https://flexie.io/resources/ai/connect-outside-assistants | https://flexie.io/resources/ai/connect-outside-assistants.md |
| Knowledge bases (Brains) | https://flexie.io/resources/ai/knowledge-bases | https://flexie.io/resources/ai/knowledge-bases.md |
| Overview | https://flexie.io/resources/ai/overview | https://flexie.io/resources/ai/overview.md |
| Settings & models | https://flexie.io/resources/ai/settings-and-models | https://flexie.io/resources/ai/settings-and-models.md |
| Specialists | https://flexie.io/resources/ai/specialists | https://flexie.io/resources/ai/specialists.md |
| What the assistant can do | https://flexie.io/resources/ai/what-it-can-do | https://flexie.io/resources/ai/what-it-can-do.md |
| Cases & Support | https://flexie.io/resources/crm/cases-and-support | https://flexie.io/resources/crm/cases-and-support.md |
| Contacts & Leads | https://flexie.io/resources/crm/contacts-and-leads | https://flexie.io/resources/crm/contacts-and-leads.md |
| Deals & Pipelines | https://flexie.io/resources/crm/deals-and-pipelines | https://flexie.io/resources/crm/deals-and-pipelines.md |
| Custom Records & Fields | https://flexie.io/resources/customization/custom-records-and-fields | https://flexie.io/resources/customization/custom-records-and-fields.md |
| Built-In Widgets | https://flexie.io/resources/dashboards/built-in-widgets | https://flexie.io/resources/dashboards/built-in-widgets.md |
| Custom HTML Widgets | https://flexie.io/resources/dashboards/custom-html-widgets | https://flexie.io/resources/dashboards/custom-html-widgets.md |
| Layout & Sharing | https://flexie.io/resources/dashboards/layout-and-sharing | https://flexie.io/resources/dashboards/layout-and-sharing.md |
| Overview | https://flexie.io/resources/dashboards/overview | https://flexie.io/resources/dashboards/overview.md |
| Report Widgets | https://flexie.io/resources/dashboards/report-widgets | https://flexie.io/resources/dashboards/report-widgets.md |
| Data Quality | https://flexie.io/resources/data-quality/overview | https://flexie.io/resources/data-quality/overview.md |
| Authentication & CORS | https://flexie.io/resources/dynamic-endpoints/authentication-and-cors | https://flexie.io/resources/dynamic-endpoints/authentication-and-cors.md |
| Creating an Endpoint | https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint | https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint.md |
| End-to-End Examples | https://flexie.io/resources/dynamic-endpoints/examples | https://flexie.io/resources/dynamic-endpoints/examples.md |
| Overview | https://flexie.io/resources/dynamic-endpoints/overview | https://flexie.io/resources/dynamic-endpoints/overview.md |
| Receiving Data | https://flexie.io/resources/dynamic-endpoints/receiving-data | https://flexie.io/resources/dynamic-endpoints/receiving-data.md |
| Responding to the Caller | https://flexie.io/resources/dynamic-endpoints/responding | https://flexie.io/resources/dynamic-endpoints/responding.md |
| Virtual Conditions | https://flexie.io/resources/dynamic-endpoints/virtual-conditions | https://flexie.io/resources/dynamic-endpoints/virtual-conditions.md |
| Virtual Entities | https://flexie.io/resources/dynamic-endpoints/virtual-entities | https://flexie.io/resources/dynamic-endpoints/virtual-entities.md |
| Accounting | https://flexie.io/resources/finance/accounting | https://flexie.io/resources/finance/accounting.md |
| Convert to Cash | https://flexie.io/resources/finance/convert-to-cash | https://flexie.io/resources/finance/convert-to-cash.md |
| Invoices | https://flexie.io/resources/finance/invoices | https://flexie.io/resources/finance/invoices.md |
| Overview | https://flexie.io/resources/finance/overview | https://flexie.io/resources/finance/overview.md |
| Payments | https://flexie.io/resources/finance/payments | https://flexie.io/resources/finance/payments.md |
| Products | https://flexie.io/resources/finance/products | https://flexie.io/resources/finance/products.md |
| Quotes | https://flexie.io/resources/finance/quotes | https://flexie.io/resources/finance/quotes.md |
| Taxes | https://flexie.io/resources/finance/taxes | https://flexie.io/resources/finance/taxes.md |
| Flexie Scripting: Filters & Working with Lists | https://flexie.io/resources/flexie-scripting/filters-and-collections | https://flexie.io/resources/flexie-scripting/filters-and-collections.md |
| Flexie Scripting: Function Reference | https://flexie.io/resources/flexie-scripting/function-reference | https://flexie.io/resources/flexie-scripting/function-reference.md |
| Flexie Scripting: Language Basics | https://flexie.io/resources/flexie-scripting/language-basics | https://flexie.io/resources/flexie-scripting/language-basics.md |
| Overview | https://flexie.io/resources/flexie-scripting/overview | https://flexie.io/resources/flexie-scripting/overview.md |
| Flexie Scripting: Recipes | https://flexie.io/resources/flexie-scripting/recipes | https://flexie.io/resources/flexie-scripting/recipes.md |
| Flexie Scripting: Where It Runs & Its Limits | https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits | https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits.md |
| Creating a Form | https://flexie.io/resources/forms/creating-a-form | https://flexie.io/resources/forms/creating-a-form.md |
| Forms in Workflows | https://flexie.io/resources/forms/forms-in-workflows | https://flexie.io/resources/forms/forms-in-workflows.md |
| Internal Forms | https://flexie.io/resources/forms/internal-forms | https://flexie.io/resources/forms/internal-forms.md |
| Overview | https://flexie.io/resources/forms/overview | https://flexie.io/resources/forms/overview.md |
| Public (External) Forms | https://flexie.io/resources/forms/public-forms | https://flexie.io/resources/forms/public-forms.md |
| Submissions | https://flexie.io/resources/forms/submissions | https://flexie.io/resources/forms/submissions.md |
| Getting Started | https://flexie.io/resources/getting-started/introduction | https://flexie.io/resources/getting-started/introduction.md |
| Email Channel | https://flexie.io/resources/inbox/email | https://flexie.io/resources/inbox/email.md |
| Overview | https://flexie.io/resources/inbox/overview | https://flexie.io/resources/inbox/overview.md |
| SMS Channel | https://flexie.io/resources/inbox/sms | https://flexie.io/resources/inbox/sms.md |
| Templates (Email & SMS) | https://flexie.io/resources/inbox/templates | https://flexie.io/resources/inbox/templates.md |
| WhatsApp Channel | https://flexie.io/resources/inbox/whatsapp | https://flexie.io/resources/inbox/whatsapp.md |
| Inbox in Workflows | https://flexie.io/resources/inbox/workflows-and-automation | https://flexie.io/resources/inbox/workflows-and-automation.md |
| Integrations & Developer Access | https://flexie.io/resources/integrations/integrations-and-api | https://flexie.io/resources/integrations/integrations-and-api.md |
| Call Logs & Timeline | https://flexie.io/resources/phone/call-logs-and-timeline | https://flexie.io/resources/phone/call-logs-and-timeline.md |
| Channels | https://flexie.io/resources/phone/channels | https://flexie.io/resources/phone/channels.md |
| Live Monitor | https://flexie.io/resources/phone/live-monitor | https://flexie.io/resources/phone/live-monitor.md |
| Overview | https://flexie.io/resources/phone/overview | https://flexie.io/resources/phone/overview.md |
| The Softphone | https://flexie.io/resources/phone/softphone | https://flexie.io/resources/phone/softphone.md |
| Workflows | https://flexie.io/resources/phone/workflows-and-automation | https://flexie.io/resources/phone/workflows-and-automation.md |
| Data Grid Reports | https://flexie.io/resources/reports/data-grid-reports | https://flexie.io/resources/reports/data-grid-reports.md |
| Report Filters (in depth) | https://flexie.io/resources/reports/filters | https://flexie.io/resources/reports/filters.md |
| HTML Reports | https://flexie.io/resources/reports/html-reports | https://flexie.io/resources/reports/html-reports.md |
| Overview | https://flexie.io/resources/reports/overview | https://flexie.io/resources/reports/overview.md |
| Reports in Workflows & Dashboards | https://flexie.io/resources/reports/reports-in-workflows-and-widgets | https://flexie.io/resources/reports/reports-in-workflows-and-widgets.md |
| Viewing, Exporting & Access | https://flexie.io/resources/reports/viewing-exporting-sharing | https://flexie.io/resources/reports/viewing-exporting-sharing.md |
| Accounts, Teams & Security | https://flexie.io/resources/security/accounts-and-security | https://flexie.io/resources/security/accounts-and-security.md |
| Actions & Decisions | https://flexie.io/resources/workflows/actions-and-decisions | https://flexie.io/resources/workflows/actions-and-decisions.md |
| Building a Workflow | https://flexie.io/resources/workflows/building-a-workflow | https://flexie.io/resources/workflows/building-a-workflow.md |
| Overview | https://flexie.io/resources/workflows/overview | https://flexie.io/resources/workflows/overview.md |
| Passing Data Between Steps | https://flexie.io/resources/workflows/passing-data-between-steps | https://flexie.io/resources/workflows/passing-data-between-steps.md |
| Runtime, Parallel Execution & the Tree | https://flexie.io/resources/workflows/runtime-parallel-and-tree | https://flexie.io/resources/workflows/runtime-parallel-and-tree.md |
| Scheduling, Testing & Troubleshooting | https://flexie.io/resources/workflows/scheduling-testing-troubleshooting | https://flexie.io/resources/workflows/scheduling-testing-troubleshooting.md |
| Triggers & Sources | https://flexie.io/resources/workflows/triggers-and-sources | https://flexie.io/resources/workflows/triggers-and-sources.md |
| Security & Infrastructure | https://flexie.io/security-infrastructure | https://flexie.io/security-infrastructure.md |
| Terms of Service | https://flexie.io/terms | https://flexie.io/terms.md |

---

## Flexie: All-in-One Business Platform Shaped to You, with AI

Source: https://flexie.io/

Flexible by design.

# It starts as a CRM.  
It becomes your business.

Most platforms bend your business to fit their assumptions. Flexie does the opposite. Sales, billing, support, communication, forms, dashboards, and automation on one programmable engine shaped to how you work, with an AI workforce that handles the busywork.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

Explore a real workspace on your own, or get honest advice, even if Flexie turns out not to be the right fit.

The problem

## Your business is more complicated than any tool.

Every business has its own messy reality. Exceptions, edge cases, side-agreements, processes someone invented on a Tuesday in 2019\. Most tools flatten you to fit. Flexie shapes to fit you.

Pipeline

11 pipeline stages, of which 4 only apply to SMB leads and 3 add a procurement flow for enterprise.

Billing

4 invoice currencies, 5 different billing cycles, and 12 accounts on custom pricing arrangements.

Policy

A refund policy with 3 exceptions, plus 2 exceptions to those exceptions.

Customer data

Half your customer data lives in spreadsheets because the fields you actually need don't exist.

Flexie shapes to all of this. No flattening required.

What "shaped" actually means

## Your records. Your fields. Your pipelines. Your flow.

That isn't a slogan. In Flexie you add your own kinds of records, your own fields, link them the way your business actually connects, and design your own pipelines and forms. The platform ends up matching your operations and flow, not the other way around.

Custom recordsCustom fieldsLinked recordsYour own formsCustom dashboardsCustom pipelines

Track anything your business runs on

Properties

Projects

Contracts

Vehicles

Memberships

Equipment

Appointments

Inventory

Assets

Suppliers

Bookings

Anything else

We tailor it to your business in a one-time implementation, then you adjust it as you grow with point-and-click screens, no code needed.

One connected platform

## Everything your business runs on, working as one.

Not a single tool with add-ons. A complete platform where sales, billing, support, and communication are built to work together, so your data is always in sync. One offer, every module included, with no per-user fees and nothing locked behind a higher tier.

### Sales & CRM

Leads, contacts, and deals on a visual pipeline.

### Billing & Finance

Quotes, invoices, and recurring plans that bill themselves.

### Communication

Email, SMS, WhatsApp, and a built-in phone, on one timeline.

### Support & Cases

Turn customer questions into trackable cases.

### Automation

“When this happens, do that.” Running around the clock.

### Custom Records

Track anything, with your own fields and lists.

### Dashboards

Your numbers, live, in clear charts and reports.

### Integrations

Connect your other tools, and your AI, securely.

Flexie AI

## Not an assistant. A workforce.

Most CRMs bolted on a chat box. Flexie built a workforce. The same engine that runs your sales, billing, and support runs an AI that moves from “set up my CRM” to “run my CRM”, audits the data, and takes action under your supervision. Never sleeps, remembers what matters, works at the speed of typing.

### Chat with it

Ask in plain words for a list, a report, or a new automation, and watch it happen.

### Build it into your workflows

Drop an AI Agent into any process. It works unattended, day and night, at scale.

### Run it from your phone

Text your business like you'd text a colleague. It does the work and texts back.

### It acts, it doesn't just answer

It builds the automations, runs the reports, audits the data, and takes the action.

### Always under your control

Before anything important, it shows you what it will do and waits for your approval.

### No AI vendor lock-in

Industrial-grade agents that aren't tied to one AI company. Swap the engine, keep your setup.

[See what Flexie AI can do](https://flexie.io/ai)

Connected by default

## A workday that flows on its own.

Because every part of Flexie is connected, work moves through it like an assembly line. Nobody copies data between apps, and nothing is forgotten.

Step 1

A lead fills in a form

Flexie creates the contact

Step 2

The deal is won

the invoice is ready, no retyping

Step 3

Reminders send themselves

follow-ups, on schedule

Step 4

The owner sees it all

live, on one dashboard

Loved by teams

## Teams of every size run on Flexie.

> "Flexie replaced at least 6 other apps that we used daily. Powerful workflows, complete freedom with webhooks and the API. It integrates with everything in our arsenal."

Diego G.

Real Estate · Capterra review

> "It's a CRM on steroids. One control tower for sales, contacts, support cases, tasks and automated workflows. Far less time lost jumping between tools."

António A.

Tech Startups · Capterra review

> "Truly enterprise-grade. You get everything out of the box instead of being nickel-and-dimed for features. Flexible, fast, and genuinely powerful."

Sebastian B.

Marketing & Advertising · Capterra review

## Ready to shape it to your business?

Explore the live demo on your own, or book a free consultation. We'll learn your business, give you a straight price, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## About Flexie

Source: https://flexie.io/about

Our story

# Software should adapt to your business.  
Not the other way around.

That belief did not come from a brainstorm. It came from more than a decade of building software for other companies, and seeing, again and again, where the usual approach broke down.

2010

## It started as a software house.

Flexie did not begin as a product, or even as Flexie. In 2010 we opened a software house called RT Software Group, taking on outsourced development for clients who needed software built properly. For a few years that was the work: someone described a problem, we built the system to solve it.

Those years were an education. We learned how very different businesses actually run behind the scenes, and we watched, up close, how software either carried a team forward or quietly got in their way.

2014

## Then we went deep on CRM.

In 2014 we narrowed our focus to CRM, and two contracts pulled us all the way in. One was a vertical SaaS CRM for the real estate industry in the United States. The other was a vertical platform for the tourism industry in Denmark.

We did not just write the code and walk away. We sat with the businesses using these products, watched them onboard their teams, and lived with the day-to-day reality of adoption. Building deeply for one industry, for real customers, taught us something we did not expect.

What we learned

Even two companies in the same industry, the same size, run on different processes and chase different strategies. A vertical product can take them part of the way. It cannot take them all the way. The software has to adapt to the business, not the business to the software.

2016 to 2018

## So we built Flexie.

The answer was not a better vertical. It was a platform that could be shaped to whatever a business actually did, one programmable engine underneath sales, billing, support, communication, and the automation tying them together.

In 2016 we started building Flexie, with a handful of early adopters shaping it alongside us, and in 2018 we opened it to the market.

The product came to define us so completely that we took its name. RT Software Group became Flexie. The name says it plainly: Flexie, for flexible, the adaptability a business needs from the software at its core.

Today, and next

## At the core of how our customers run.

Since 2018, Flexie has been put to work across very different industries, and in each one it settles into the same place: the core of how the company runs, orchestrating the processes the whole operation depends on, day in and day out. We run it from Innsbruck, Austria, for customers spread across the world.

Our next chapter is AI. We are going all-in on AI Agents, not a chat box bolted onto a CRM, but agents that work inside your processes, take on the repetitive load, and change how the work actually gets executed, always under your team's control. The thesis holds: the software adapts to you, and now it works alongside you.

What the journey taught us

## What we believe.

### Adapt to the business

The reason Flexie exists. You should never have to bend how you work to fit a tool. Records, fields, pipelines, and workflows are shaped to you, not the reverse.

### Honest over flashy

We would rather tell you Flexie is the wrong fit than close a bad sale. Straight pricing, straight answers, and no lock-in to trap you later.

### AI that acts, people in charge

Agents take on the repetitive work your team hands them, inside your processes, with approvals before anything sensitive. Your people still run the business.

## See if it fits your business.

Book a call and we will look at how your business actually runs, then tell you honestly whether Flexie is the right fit. Or open the live demo and explore it on your own.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Flexie AI: An AI Workforce That Acts on Your Data

Source: https://flexie.io/ai

Flexie AI

# An AI workforce that acts on your data.

Flexie AI works inside the same workspace your team uses. It reads your real records, runs your workflows, drafts and sends on your behalf, and stops to ask before anything material changes. Your own AI vendor, your own models, your own bill, never locked in.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

Acts, not just answersVendor-independentApprovals before anything materialPlays by your permissions

Way one · chat with tools

## Ask for an outcome. It reaches for real tools and does it.

Most AI in business tools answers your question, then leaves the work to you. Flexie AI is on the other side of that line. Ask for an outcome and it reaches for real tools wired into your workspace: it reads your records, writes your fields, drafts your messages, builds your workflows, and runs your reports. Every step is a call against your live data that you can see before it lands.

* Live tools, not a model in a box  
Read records, write fields, send messages, create workflows. Each tool is a real action against your workspace.
* Talks back with the receipt  
You see what ran, on which rows, with what result. Nothing happens in a black box.
* Plain words, no special syntax  
Ask the way you would brief a colleague. No filters to build, no commands to memorise.
* Stops to ask when it matters  
Reads are quiet; writes and sends pause for a one-tap approval, so nothing material goes out unreviewed.
* Works with your data model  
Knows your custom records, your fields, your pipelines. Answers in the shape of your business, not a generic CRM.
* Picks up where you left off  
Remembers the records you were working on, so 'now do the same for next month' just works.

[How chat with tools works](https://flexie.io/resources/ai/what-it-can-do)

Way two · AI Agent in workflows

## Drop an AI Agent into any process. It runs unattended, every time.

Chat is the front door, but businesses run on processes. The AI Agent is an action you drop into any workflow. Give it a goal in plain words and the tools it may use, and every time the workflow fires it reads the inputs, makes the call, and routes the flow forward. Day or night, on one record or ten thousand, the same way every time.

* A goal, not a script  
Brief the Agent in plain words and it handles each run within the rules and tools you set, no step-by-step script to maintain.
* Only the tools you allow  
You choose which tools and data each Agent can touch, so the one handling support cases cannot post invoices.
* Branches on its own judgement  
The Agent can choose the path: auto-resolve, draft and assign, or escalate. The workflow takes it from there.
* Runs unattended, at scale  
Triggered by record events, schedules, or incoming messages. Handles thousands of runs without slowing down.
* Per-agent vendor and model  
Light triage on a small model, deep audits on a premium one. Each Agent runs on the engine you choose.
* Auditable like any workflow  
Every decision, every tool call, every result is logged on the record the Agent acted on.

[Read Workflows docs](https://flexie.io/resources/workflows/overview)

Way three · text and WhatsApp

## Run your business from the messaging app already on your phone.

Set it up once and your business number becomes an AI line. Text it on SMS or WhatsApp the way you would text a colleague. The AI reads the message, opens the workspace, gets the answer or does the work, and texts back. No app to install, no login to remember, no laptop to find. The whole platform fits in a thread.

* Plain text, plain answers  
Ask for numbers, request an action, send a quick instruction. Replies arrive with the receipt.
* Approvals in the thread  
Before anything material goes out, the AI shows you what it is about to do and waits for your yes.
* Same AI, same tools  
Not a downgraded mobile assistant. Same workforce, same access, same approval rules as the desktop chat.
* Filter who reaches it  
Lock the channel to your phone number, or a small group of trusted ones, and ignore the rest.
* Works on your existing number  
Use the SMS or WhatsApp number you already publish, no new line to print on business cards.
* Owner-first, on the road  
For people who run the business between meetings, sites, and flights, not from a desk.

[Read Inbox docs](https://flexie.io/resources/inbox/overview)

No AI vendor lock-in

## Your vendor. Your models. Your bill. Never the platform's.

Most platforms charge you for AI you cannot see, on a model you cannot pick, from a vendor they chose. Flexie does the opposite. Connect your own OpenAI, Anthropic, Google, or self-hosted account, and Flexie runs on it for you. You configure the experts, Flexie routes each request to the right one. The intelligence is yours, the bill goes to your provider, and the runtime stays the same the day you swap an engine out.

* Bring your own vendor accounts  
OpenAI, Anthropic, Google, DeepSeek, or self-hosted Ollama for work you keep in house.
* Multiple experts, one Flexie AI  
Configure an expert per job, each with its own model, instructions, and tools. Flexie routes every request to the right one.
* The runtime is ours  
The tools, the routing, and the memory that make the AI useful stay independent of any vendor.
* Swap engines without rewiring  
A better model lands tomorrow? Point your experts at it, and your workflows and tools keep working.
* Connect outside AI tools  
Open your data to an AI tool you already use, through the open industry standard (MCP), under the same permissions.
* No platform-AI margin  
Flexie does not mark up tokens. You pay your AI provider directly for what you use.

[How vendors and models work](https://flexie.io/resources/ai/settings-and-models)

Memory · across sessions

## It remembers your business, not just the current chat.

Close the tab and most assistants forget everything. Flexie AI keeps the context that matters across sessions: the way your business is set up, the records you were working on, and the decisions you have already made. So you can come back days later, say 'now do the same for this quarter', and it knows exactly what you mean.

* Remembers across sessions  
Come back tomorrow or next month and the context you built up is still there, not reset to zero.
* Knows how you are set up  
Your records, fields, and pipelines. It answers in the shape of your business, not a generic CRM.
* Builds on your last request  
Say 'now do the same for last month' and it carries the thread forward, with nothing to re-explain.
* Keeps the decisions you made  
A rule or preference you set once stays in effect, so you are not repeating yourself every time.
* Sharp, not noisy  
It surfaces the context that fits what you are asking instead of dragging in everything at once.
* Always within your permissions  
It only ever recalls what the person asking is allowed to see, the same rules as the rest of Flexie.

[How memory works](https://flexie.io/resources/ai/chat-assistant)

Under your control

## Acts on your data. Asks before anything material.

Power without supervision is a liability. Flexie's AI is careful by design: it shows its plan before sending a message, posting a record, or switching on a workflow, and waits for a one-tap approval. It plays by the same access rules as the person who asked, so it never sees or touches anything they are not allowed to. You can let it run unattended where it should, and hold it on a leash everywhere else.

* Plan before action  
Material changes are shown as a plan you approve before they run.
* Per-expert permissions  
Each expert gets only the tools and data its job needs, nothing more.
* Same access as the user  
The AI inherits your permissions, never elevates beyond them.
* Full audit trail  
Every tool call, every decision, every result is logged on the record.

What teams build with Flexie AI

## Real jobs handed to the AI. No demo magic.

Six concrete shapes we see in working installs, not features in a brochure. Every one ships on the same chat, Agent, and runtime.

Support

### Around-the-clock support

An AI Agent on the support inbox triages every email overnight, replies to the simple ones, drafts the rest for the morning shift, and escalates the angry ones. The team walks in to a clean queue.

AI AgentInboxWorkflows

Sales

### Lead intake that doesn't sleep

Form submissions, ads, WhatsApp, and incoming email all funnel through one Agent that scores, enriches, books a slot, and replies. By the time a rep opens it, the meeting is on the calendar.

AI AgentFormsMessaging

Revenue ops

### Nightly deal-risk audit

Every night an Agent reads the top open deals, weighs them against your historical deal data, and posts a short risk briefing to the sales lead. Saves Mondays.

AI AgentReportsLive data

Founder ops

### Owner runs the business by text

The founder texts the business number from anywhere. 'How is this week?' 'Remind the late ones.' 'Send the team yesterday's wins.' The AI does it and texts back the receipt.

WhatsAppChatApprovals

Operations

### Self-rebuilding workflows

Ask the chat to 'build a follow-up sequence for unpaid invoices over thirty days'. The AI assembles the workflow, shows the plan, and switches it on after you approve.

Chat with toolsWorkflows

Regulated

### Compliance-friendly local AI

Sensitive workloads route to a self-hosted Ollama model on the customer's own server. Vendor-independence makes a hybrid setup a configuration choice, not an architecture rewrite.

OllamaVendor freedomOn-prem

Plain speak

## This is a working AI, not a feature box. Read both columns.

Flexie's AI is built to do real work, on your real data, with your real rules. That's a fit for some businesses and overkill for others. We say it both ways.

### Where Flexie AI pays off

* You want AI that acts inside your platform, not a separate chat tab.
* You want one Agent per job, with its own tools and its own model.
* You want to bring your own AI vendor, on your own bill.
* You want unattended automations with judgement, not just rule branches.
* You want approvals on anything that touches the customer or the books.
* You want AI that knows your data model and your rules, not a generic chatbot.

### Where it is overkill

* You just want a writing assistant in a sidebar.
* You want a single bundled AI bill rolled into the platform's price.
* You are not ready to grant any tool access to a model, only suggestions.
* Your processes are simple enough that a rules-only flow already handles them.
* You want the AI to take action without a human ever approving anything.
* You expect the platform to pick the AI vendor and you to never see it.

## Put an AI workforce on the work.

Click around the live demo to see Flexie AI act on a real workspace, or book a free consultation. We will learn your business, give you a straight price, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## API Reference | Flexie REST API for Contacts, Deals, Cases & More

Source: https://flexie.io/api

REST API

# Build on your  
Flexie data.

A standard REST API over everything in your workspace: contacts, leads, deals, cases, tasks, and your own custom records. Predictable URLs, API-key auth, and JSON in and out, with 142 endpoints across 15 resource groups.

[Read the quickstart](#quickstart)[Download the OpenAPI spec](https://flexie.io/flexie-api.json)

OpenAPI 1.0.1 (Swagger 2.0). Import it into Postman, Insomnia, or your own client.

Quickstart

## Your first request, in a minute.

Every workspace has its own API host. Send your key with each request and you're talking to your live data.

Base URL

https://your-subdomain.flexie.io/api

Your API URL is your subdomain, then `/api/`, then the endpoint, for example `/api/leads`.

Authentication

Send your key in the `apikey` header, or as an `?apikey=` query parameter. Your key lives in your account settings, under API Settings. Prefer OAuth 2.0? That's supported too.

List contacts

```
curl https://your-subdomain.flexie.io/api/contacts \
  -H "apikey: YOUR_API_KEY"
```

Create a contact

```
curl -X POST https://your-subdomain.flexie.io/api/contacts/new \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "firstname": "Jane",
    "lastname": "Doe",
    "email": "jane@acme.com"
  }'
```

Every response is JSON, including errors.

Conventions

## Predictable by design.

### Resource URLs

Each resource has a clean path. List at `/api/contacts`, fetch one at `/api/contacts/{id}`.

### Standard verbs

GET to read, POST to create, PUT to update, DELETE to remove.

### JSON everywhere

Requests and responses are JSON, and so are errors, so you can parse one shape every time.

Status codes

200

Request succeeded.

204

Succeeded with nothing to return (e.g. a delete).

400

Bad request: something in the input was malformed.

404

No record matched the request.

500

Something went wrong on our side.

Endpoint reference

## 142 endpoints, grouped by what they touch.

Click any endpoint for a copy-ready request example. Field names are the default set, so an account with custom fields will use its own aliases. Download the OpenAPI spec for full response schemas.

[Contact16](#g-contact)[Lead16](#g-lead)[Accounts16](#g-accounts)[Deals16](#g-deals)[Cases20](#g-cases)[Tasks9](#g-tasks)[Notes4](#g-notes)[Emails4](#g-emails)[Custom entities16](#g-custom-entities)[Workflows6](#g-workflows)[Forms2](#g-forms)[Pages3](#g-pages)[Reports3](#g-reports)[Users8](#g-users)[Roles3](#g-roles)

### Contact

People you do business with, plus contact lists and segmentation.

16 endpoints

GET`/api/contact/lists`Filter Contact Lists

```
curl "https://your-subdomain.flexie.io/api/contact/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/contact/lists/{id}/add/{entityId}`Add a contact to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/contact/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/contact/lists/{id}/remove/{entityId}`Remove a contact from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/contact/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts`List Contacts

```
curl "https://your-subdomain.flexie.io/api/contacts?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/contacts`List Contacts

```
curl -X POST "https://your-subdomain.flexie.io/api/contacts" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/contacts/{id}`Get Contact

```
curl "https://your-subdomain.flexie.io/api/contacts/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/contacts/{id}`Update Contact

```
curl -X PUT "https://your-subdomain.flexie.io/api/contacts/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "david.okafor@example.com",
    "company": "Bluewave Logistics Ltd",
    "city": "Manchester",
    "status": "Nurture",
    "source": "Referral"
  }'
```

DELETE`/api/contacts/{id}`Delete Contact

```
curl -X DELETE "https://your-subdomain.flexie.io/api/contacts/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts/{id}/lists`Get Contact Lists

```
curl "https://your-subdomain.flexie.io/api/contacts/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts/{id}/notes`Get Contact Notes

```
curl "https://your-subdomain.flexie.io/api/contacts/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts/{id}/workflows`Get Contact Workflows

```
curl "https://your-subdomain.flexie.io/api/contacts/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/contacts/edit`Update Contact By Unique Field

```
curl -X PUT "https://your-subdomain.flexie.io/api/contacts/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "david.okafor@example.com",
    "company": "Bluewave Logistics Ltd",
    "city": "Manchester",
    "status": "Nurture",
    "source": "Referral"
  }'
```

GET`/api/contacts/list/fields`List Contact Fields

```
curl "https://your-subdomain.flexie.io/api/contacts/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts/list/fields/categories`List Contact Field Categories

```
curl "https://your-subdomain.flexie.io/api/contacts/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/contacts/list/lists`List Contact Lists

```
curl "https://your-subdomain.flexie.io/api/contacts/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/contacts/new`Create Contact

```
curl -X POST "https://your-subdomain.flexie.io/api/contacts/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Ms.",
    "first_name": "David",
    "last_name": "Okafor",
    "email": "david.okafor@example.com",
    "phone": "+442071838750",
    "company": "Bluewave Logistics",
    "city": "London",
    "country": "United Kingdom",
    "status": "New",
    "source": "Meeting"
  }'
```

### Lead

Inbound and outbound leads, from capture through qualification.

16 endpoints

GET`/api/lead/lists`Filter Lead Lists

```
curl "https://your-subdomain.flexie.io/api/lead/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/lead/lists/{id}/add/{entityId}`Add a lead to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/lead/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/lead/lists/{id}/remove/{entityId}`Remove a lead from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/lead/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads`List Leads

```
curl "https://your-subdomain.flexie.io/api/leads?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/leads`List Leads

```
curl -X POST "https://your-subdomain.flexie.io/api/leads" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/leads/{id}`Get Lead

```
curl "https://your-subdomain.flexie.io/api/leads/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/leads/{id}`Update Lead

```
curl -X PUT "https://your-subdomain.flexie.io/api/leads/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "maria.hernandez@example.com",
    "company": "Northwind Trading LLC",
    "city": "Dallas",
    "status": "Qualify",
    "source": "Referral"
  }'
```

DELETE`/api/leads/{id}`Delete Lead

```
curl -X DELETE "https://your-subdomain.flexie.io/api/leads/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads/{id}/lists`Get Lead Lists

```
curl "https://your-subdomain.flexie.io/api/leads/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads/{id}/notes`Get Lead Notes

```
curl "https://your-subdomain.flexie.io/api/leads/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads/{id}/workflows`Get Lead Workflows

```
curl "https://your-subdomain.flexie.io/api/leads/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/leads/edit`Update Lead By Unique FIeld

```
curl -X PUT "https://your-subdomain.flexie.io/api/leads/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "maria.hernandez@example.com",
    "company": "Northwind Trading LLC",
    "city": "Dallas",
    "status": "Qualify",
    "source": "Referral"
  }'
```

GET`/api/leads/list/fields`List Lead Fields

```
curl "https://your-subdomain.flexie.io/api/leads/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads/list/fields/categories`List Lead Field Categories

```
curl "https://your-subdomain.flexie.io/api/leads/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/leads/list/lists`List Lead Lists

```
curl "https://your-subdomain.flexie.io/api/leads/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/leads/new`Create Lead

```
curl -X POST "https://your-subdomain.flexie.io/api/leads/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Mr.",
    "first_name": "Maria",
    "last_name": "Hernandez",
    "email": "maria.hernandez@example.com",
    "phone": "+15125550148",
    "company": "Northwind Trading",
    "city": "Austin",
    "state": "TX",
    "country": "United States",
    "status": "New",
    "source": "Website"
  }'
```

### Accounts

Companies and organizations, with their related records.

16 endpoints

GET`/api/account/lists`Filter Account Lists

```
curl "https://your-subdomain.flexie.io/api/account/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/account/lists/{id}/add/{entityId}`Add an account to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/account/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/account/lists/{id}/remove/{entityId}`Remove an account from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/account/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts`List Accounts

```
curl "https://your-subdomain.flexie.io/api/accounts?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/accounts`List Accounts

```
curl -X POST "https://your-subdomain.flexie.io/api/accounts" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/accounts/{id}`Get Account

```
curl "https://your-subdomain.flexie.io/api/accounts/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/accounts/{id}`Update Account

```
curl -X PUT "https://your-subdomain.flexie.io/api/accounts/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Northwind Trading LLC",
    "status": "Qualify",
    "annual_revenue": 5200000,
    "employees": 145
  }'
```

DELETE`/api/accounts/{id}`Delete Account

```
curl -X DELETE "https://your-subdomain.flexie.io/api/accounts/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts/{id}/lists`Get Account Lists

```
curl "https://your-subdomain.flexie.io/api/accounts/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts/{id}/notes`Get Account Notes

```
curl "https://your-subdomain.flexie.io/api/accounts/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts/{id}/workflows`Get Account Workflows

```
curl "https://your-subdomain.flexie.io/api/accounts/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/accounts/edit`Update Account By Unique FIeld

```
curl -X PUT "https://your-subdomain.flexie.io/api/accounts/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Northwind Trading LLC",
    "status": "Qualify",
    "annual_revenue": 5200000,
    "employees": 145
  }'
```

GET`/api/accounts/list/fields`List Account Fields

```
curl "https://your-subdomain.flexie.io/api/accounts/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts/list/fields/categories`List Account Field Categories

```
curl "https://your-subdomain.flexie.io/api/accounts/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/accounts/list/lists`List Account Lists

```
curl "https://your-subdomain.flexie.io/api/accounts/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/accounts/new`Create Account

```
curl -X POST "https://your-subdomain.flexie.io/api/accounts/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Northwind Trading LLC",
    "status": "New",
    "email": "info@northwindtrading.com",
    "website": "https://www.northwindtrading.com",
    "phone": "+15125550100",
    "industry": "Retail",
    "annual_revenue": 4500000,
    "vat_number": "GB123456789",
    "employees": 120,
    "billing_city": "Austin",
    "billing_country": "United States"
  }'
```

### Deals

Opportunities moving through your sales pipelines.

16 endpoints

GET`/api/deal/lists`Filter Deal Lists

```
curl "https://your-subdomain.flexie.io/api/deal/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/deal/lists/{id}/add/{entityId}`Add a deal to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/deal/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/deal/lists/{id}/remove/{entityId}`Remove a deal from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/deal/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals`List Deals

```
curl "https://your-subdomain.flexie.io/api/deals?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/deals`List Deals

```
curl -X POST "https://your-subdomain.flexie.io/api/deals" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/deals/{id}`Get Deal

```
curl "https://your-subdomain.flexie.io/api/deals/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/deals/{id}`Update Deal

```
curl -X PUT "https://your-subdomain.flexie.io/api/deals/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Enterprise license renewal",
    "amount": 15000,
    "close_date": "2026-10-15",
    "stage_id": 3
  }'
```

DELETE`/api/deals/{id}`Delete Deal

```
curl -X DELETE "https://your-subdomain.flexie.io/api/deals/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals/{id}/lists`Get Deal Lists

```
curl "https://your-subdomain.flexie.io/api/deals/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals/{id}/notes`Get Deal Notes

```
curl "https://your-subdomain.flexie.io/api/deals/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals/{id}/workflows`Get Deal Workflows

```
curl "https://your-subdomain.flexie.io/api/deals/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/deals/edit`Update Deal By Unique FIeld

```
curl -X PUT "https://your-subdomain.flexie.io/api/deals/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Enterprise license renewal",
    "amount": 15000,
    "close_date": "2026-10-15",
    "stage_id": 3
  }'
```

GET`/api/deals/list/fields`List Deal Fields

```
curl "https://your-subdomain.flexie.io/api/deals/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals/list/fields/categories`List Deal Field Categories

```
curl "https://your-subdomain.flexie.io/api/deals/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/deals/list/lists`List Deal Lists

```
curl "https://your-subdomain.flexie.io/api/deals/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/deals/new`Create Deal

```
curl -X POST "https://your-subdomain.flexie.io/api/deals/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Enterprise license renewal",
    "amount": 12500,
    "close_date": "2026-09-30",
    "pipeline_id": 1,
    "stage_id": 2,
    "owner_id": 3
  }'
```

### Cases

Support tickets and service requests, end to end.

20 endpoints

GET`/api/case/lists`Filter Case Lists

```
curl "https://your-subdomain.flexie.io/api/case/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/case/lists/{id}/add/{entityId}`Add a case to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/case/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/case/lists/{id}/remove/{entityId}`Remove a case from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/case/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases`List Cases

```
curl "https://your-subdomain.flexie.io/api/cases?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/cases`List Cases

```
curl -X POST "https://your-subdomain.flexie.io/api/cases" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/cases/{id}`Get Case

```
curl "https://your-subdomain.flexie.io/api/cases/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/cases/{id}`Update Case

```
curl -X PUT "https://your-subdomain.flexie.io/api/cases/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Login page returns 500 error",
    "priority": "Medium",
    "public_status": "In Process",
    "internalStatus": "open"
  }'
```

DELETE`/api/cases/{id}`Delete Case

```
curl -X DELETE "https://your-subdomain.flexie.io/api/cases/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases/{id}/lists`Get Case Lists

```
curl "https://your-subdomain.flexie.io/api/cases/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases/{id}/notes`Get Case Notes

```
curl "https://your-subdomain.flexie.io/api/cases/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases/{id}/replies`Get Case Replies

```
curl "https://your-subdomain.flexie.io/api/cases/42/replies" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/cases/{id}/replies`Add Case Reply

```
curl -X POST "https://your-subdomain.flexie.io/api/cases/42/replies" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Thanks for reaching out. We have reset your account, so you should be able to log in now."
  }'
```

GET`/api/cases/{id}/workflows`Get Case Workflows

```
curl "https://your-subdomain.flexie.io/api/cases/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/cases/edit`Update Case By Unique Field

```
curl -X PUT "https://your-subdomain.flexie.io/api/cases/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Login page returns 500 error",
    "priority": "Medium",
    "public_status": "In Process",
    "internalStatus": "open"
  }'
```

GET`/api/cases/list/fields`List Case Fields

```
curl "https://your-subdomain.flexie.io/api/cases/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases/list/fields/categories`List Case Field Categories

```
curl "https://your-subdomain.flexie.io/api/cases/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/cases/list/lists`List Case Lists

```
curl "https://your-subdomain.flexie.io/api/cases/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/cases/new`Create Case

```
curl -X POST "https://your-subdomain.flexie.io/api/cases/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Login page returns 500 error",
    "source": "Email",
    "category": "Bug",
    "priority": "High",
    "public_status": "New Opened",
    "internalStatus": "open",
    "owner_id": 3
  }'
```

GET`/api/cases/replies/{identifier}`Get Case Replies By Identifier

```
curl "https://your-subdomain.flexie.io/api/cases/replies/REF-1042" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/cases/replies/{identifier}`Add Case Reply By Identifier

```
curl -X POST "https://your-subdomain.flexie.io/api/cases/replies/REF-1042" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template_id": 3
  }'
```

### Tasks

To-dos and activities assigned across your team.

9 endpoints

GET`/api/tasks`List Tasks

```
curl "https://your-subdomain.flexie.io/api/tasks?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/tasks`List Tasks Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/tasks" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/tasks/{id}`Get Task

```
curl "https://your-subdomain.flexie.io/api/tasks/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/tasks/{id}`Update Task

```
curl -X PUT "https://your-subdomain.flexie.io/api/tasks/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task": "Call the customer to confirm renewal terms (rescheduled)",
    "due_date": "2026-06-26 10:00",
    "is_completed": false
  }'
```

DELETE`/api/tasks/{id}`Delete Task

```
curl -X DELETE "https://your-subdomain.flexie.io/api/tasks/42" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/tasks/{id}/complete`Complete Task

```
curl -X POST "https://your-subdomain.flexie.io/api/tasks/42/complete" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/tasks/{id}/incomplete`Incomplete Task

```
curl -X POST "https://your-subdomain.flexie.io/api/tasks/42/incomplete" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/tasks/list/categories`List Task Categories

```
curl "https://your-subdomain.flexie.io/api/tasks/list/categories" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/tasks/new`Create Task

```
curl -X POST "https://your-subdomain.flexie.io/api/tasks/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task": "Call the customer to confirm renewal terms",
    "owner_id": 3,
    "due_date": "2026-06-25 14:00",
    "association_type": "contact",
    "association_id": 47,
    "reminder_type": "email",
    "remind_minutes": 30
  }'
```

### Notes

Free-form notes attached to any record.

4 endpoints

POST`/api/notes/{entityType}/{entityId}`Create Note

```
curl -X POST "https://your-subdomain.flexie.io/api/notes/contact/17" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Discussed renewal terms and next steps with the customer.",
    "type": "call",
    "datetime": "2026-06-23T14:00:00+00:00"
  }'
```

GET`/api/notes/{id}`Get Note

```
curl "https://your-subdomain.flexie.io/api/notes/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/notes/{id}`Update Note

```
curl -X PUT "https://your-subdomain.flexie.io/api/notes/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Updated: renewal confirmed, contract sent for signature.",
    "type": "meeting"
  }'
```

DELETE`/api/notes/{id}`Delete Note

```
curl -X DELETE "https://your-subdomain.flexie.io/api/notes/42" \
  -H "apikey: YOUR_API_KEY"
```

### Emails

Email messages tied to your contacts and deals.

4 endpoints

GET`/api/emails`List Emails

```
curl "https://your-subdomain.flexie.io/api/emails?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/emails`List Emails Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/emails" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/emails/{id}`Get Email

```
curl "https://your-subdomain.flexie.io/api/emails/42" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/emails/{id}/send`Send Email

```
curl -X POST "https://your-subdomain.flexie.io/api/emails/42/send" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "limit": 100
  }'
```

### Custom entities

Your own record types, modeled to fit your business.

16 endpoints

GET`/api/ce/{tableName}`List Custom Entities

```
curl "https://your-subdomain.flexie.io/api/ce/your_table" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/ce/{tableName}`List Custom Entities

```
curl -X POST "https://your-subdomain.flexie.io/api/ce/your_table" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/ce/{tableName}/{id}`Get Custom Entity

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/ce/{tableName}/{id}`Update Custom Entity

```
curl -X PUT "https://your-subdomain.flexie.io/api/ce/your_table/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme Renewal 2026 (revised)",
    "status": "won",
    "amount": 5200
  }'
```

DELETE`/api/ce/{tableName}/{id}`Delete Custom Entity

```
curl -X DELETE "https://your-subdomain.flexie.io/api/ce/your_table/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/{id}/lists`Get Custom Entity Lists

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/42/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/{id}/notes`Get Custom Entity Notes

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/42/notes" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/{id}/workflows`Get Custom Entity Workflows

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/42/workflows" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/ce/{tableName}/edit`Update Custom Entity By Unique Field

```
curl -X PUT "https://your-subdomain.flexie.io/api/ce/your_table/edit" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme Renewal 2026 (revised)",
    "status": "won",
    "amount": 5200
  }'
```

GET`/api/ce/{tableName}/list/fields`List Custom Entity Fields

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/list/fields" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/list/fields/categories`List Custom Entity Field Categories

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/list/fields/categories" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/list/lists`List Custom Entity Lists

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/list/lists" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/ce/{tableName}/lists`Filter Custom Entity Lists

```
curl "https://your-subdomain.flexie.io/api/ce/your_table/lists" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/ce/{tableName}/lists/{id}/add/{entityId}`Add a record to a list

```
curl -X POST "https://your-subdomain.flexie.io/api/ce/your_table/lists/42/add/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/ce/{tableName}/lists/{id}/remove/{entityId}`Remove a record from a list

```
curl -X POST "https://your-subdomain.flexie.io/api/ce/your_table/lists/42/remove/17" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/ce/{tableName}/new`Create Custom Entity

```
curl -X POST "https://your-subdomain.flexie.io/api/ce/your_table/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme Renewal 2026",
    "status": "open",
    "amount": 4500
  }'
```

### Workflows

Trigger and manage automation from the outside.

6 endpoints

GET`/api/workflows`List Workflows

```
curl "https://your-subdomain.flexie.io/api/workflows?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/workflows`List Workflows Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/workflows" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/workflows/{id}`Get Workflow

```
curl "https://your-subdomain.flexie.io/api/workflows/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/workflows/{id}`Update Workflow

```
curl -X PUT "https://your-subdomain.flexie.io/api/workflows/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "VIP lead onboarding",
    "description": "Send a welcome sequence to new VIP leads",
    "category": 12,
    "isPublished": true,
    "runtime": "async"
  }'
```

DELETE`/api/workflows/{id}`Delete Workflow

```
curl -X DELETE "https://your-subdomain.flexie.io/api/workflows/42" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/workflows/list/categories`List Workflow Categories

```
curl "https://your-subdomain.flexie.io/api/workflows/list/categories" \
  -H "apikey: YOUR_API_KEY"
```

### Forms

The forms that capture data into Flexie.

2 endpoints

GET`/api/forms`List Forms

```
curl "https://your-subdomain.flexie.io/api/forms?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

GET`/api/forms/{id}`Get Form

```
curl "https://your-subdomain.flexie.io/api/forms/42" \
  -H "apikey: YOUR_API_KEY"
```

### Pages

Landing pages served by Flexie.

3 endpoints

GET`/api/pages`List Pages

```
curl "https://your-subdomain.flexie.io/api/pages?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/pages`List Pages Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/pages" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/pages/{id}`Get Page

```
curl "https://your-subdomain.flexie.io/api/pages/42" \
  -H "apikey: YOUR_API_KEY"
```

### Reports

Saved reports and the data behind them.

3 endpoints

GET`/api/reports`List Reports

```
curl "https://your-subdomain.flexie.io/api/reports?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/reports`List Reports Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/reports" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/reports/{id}`Get Report

```
curl "https://your-subdomain.flexie.io/api/reports/42" \
  -H "apikey: YOUR_API_KEY"
```

### Users

The people in your Flexie workspace.

8 endpoints

GET`/api/users`List Users

```
curl "https://your-subdomain.flexie.io/api/users?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/users`List Users Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/users" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/users/{id}`Get User

```
curl "https://your-subdomain.flexie.io/api/users/42" \
  -H "apikey: YOUR_API_KEY"
```

PUT`/api/users/{id}`Update User

```
curl -X PUT "https://your-subdomain.flexie.io/api/users/42" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "firstName": "John",
    "lastName": "Doe",
    "position": "Senior Sales Manager",
    "role": 3,
    "isPublished": true
  }'
```

DELETE`/api/users/{id}`Delete User

```
curl -X DELETE "https://your-subdomain.flexie.io/api/users/42" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/users/{id}/permission`Check Permission

```
curl -X POST "https://your-subdomain.flexie.io/api/users/42/permission" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "permissions": [
      "lead:leads:viewown",
      "lead:leads:editown"
    ]
  }'
```

POST`/api/users/new`Create User

```
curl -X POST "https://your-subdomain.flexie.io/api/users/new" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "jdoe",
    "firstName": "John",
    "lastName": "Doe",
    "email": "jdoe@example.com",
    "password": "S3cretPass!",
    "position": "Sales Manager",
    "timezone": "America/New_York",
    "locale": "en_US",
    "role": 3,
    "isPublished": true
  }'
```

GET`/api/users/self`Get Self

```
curl "https://your-subdomain.flexie.io/api/users/self" \
  -H "apikey: YOUR_API_KEY"
```

### Roles

Permission roles that govern who can do what.

3 endpoints

GET`/api/roles`List Roles

```
curl "https://your-subdomain.flexie.io/api/roles?limit=30&search=acme" \
  -H "apikey: YOUR_API_KEY"
```

POST`/api/roles`List Roles Filtered

```
curl -X POST "https://your-subdomain.flexie.io/api/roles" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "text",
        "alias": "email",
        "value": {
          "operator": "like",
          "input": "acme.com"
        },
        "strict": false,
        "starts": false,
        "ends": false
      }
    ],
    "start": 0,
    "limit": 30,
    "orderBy": "date_modified",
    "orderByDir": "DESC"
  }'
```

GET`/api/roles/{id}`Get Role

```
curl "https://your-subdomain.flexie.io/api/roles/42" \
  -H "apikey: YOUR_API_KEY"
```

[OpenAPI specDownload flexie-api.json and import it into Postman, Insomnia, or generate a client.Download the spec →](https://flexie.io/flexie-api.json)[Integrations & MCPWebhooks, native integrations, and an MCP server so AI tools can read and write your data directly.See integrations →](https://flexie.io/integrations)[Talk to usBuilding something on the API and want a hand? Tell us what you're wiring up and we'll help.Get in touch →](https://flexie.io/contact)

---

## Workflow Automation

Source: https://flexie.io/automation

Workflow automation

# Set the rules once. Let Flexie do the rest.

Turn the repeating parts of your business into workflows you build once and Flexie runs for you. Start one from anything that happens, branch it on your own rules, and let a single run reach across billing, messaging, and your other tools, with AI for the steps that need real judgment.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

Started by anythingBranches on your rulesReaches every channelAI for the hard steps

How it works

## Three pieces. That is the whole idea.

A workflow is just this: when something happens, do a few things, and make the smart choice along the way. Build it on a visual canvas by connecting blocks, or describe it and Flexie AI builds it for you.

01

### Pick a trigger

Choose what starts it: a record changes, a message or form arrives, a schedule comes round, or another tool calls in.

02

### Add the steps

Stack up what should happen: send an email or text, create a task, raise an invoice, update a record, notify the team.

03

### Add the decisions

Branch on what matters. Big account, treat them one way; everyone else, another. Flexie takes the right path on its own.

Triggers

## Start a flow from anything that happens.

Most automations wait on the wrong thing. Flexie lets each one start from the real trigger: the moment a record changes, a saved list matches, a schedule comes round, a message or form arrives, or another system calls in. Pick the source that matches what actually sets the work off, and the flow fires the instant it does.

* The moment it changes  
A record event fires in real time the second a field you care about changes, with no polling and no delay.
* Whole segments at once  
Point a flow at a saved list and it works through every record that matches, paced so nothing floods.
* On your own clock  
Run renewals, digests, and housekeeping every few minutes, hours, or days, without anyone watching the time.
* When a message lands  
An email, SMS, WhatsApp, or form submission can be the very thing that kicks the whole process off.
* When another tool calls  
A web request from your site or a partner system starts a flow the instant it arrives.
* Only the change you mean  
Watch a field moving to a specific value, so a flow fires on exactly that transition and nothing else.

[Read Triggers docs](https://flexie.io/resources/workflows/triggers-and-sources)

Every channel

## Reach customers on the channel they actually use.

A reminder is only useful if it arrives. Flexie automations send email, SMS, and WhatsApp on the accounts you already own, so a follow-up goes out wherever the customer reads it. Attach the invoice or the quote and Flexie delivers the whole thing, on time, every time, with no one in the loop.

* Email, SMS, WhatsApp  
One flow can reach any of them, picking the channel that fits the moment and the customer.
* On your own accounts  
Messages send through your mailbox, your Twilio, your WhatsApp Business number, never a line Flexie rents you.
* Documents attached  
Generate and attach an invoice or quote PDF, so the message carries everything the customer needs.
* Replies pull the flow on  
When the customer answers on any channel, that reply can start the next step of the process.
* Sent at a polite hour  
Hold customer-facing sends to a time window and skip days, so nothing goes out at 3am.
* Logged on the record  
Every send and reply is filed against the right contact, so the history is always there.

[Read Inbox docs](https://flexie.io/resources/inbox/overview)

One run, many steps

## One step feeds the next, in the right order.

Real processes are not one thing, they are a chain. Flexie carries what each step produces forward to the next, so a flow can create an invoice and then record a payment against that exact invoice, raise a case and then answer the customer with its reference. The work moves through in order, like an assembly line for your operations.

* Built like an assembly line  
Each step hands its result to the next, so a long process runs end to end in a single flow.
* Uses what it just made  
A step can act on the exact record an earlier step created, down to the new invoice's own id.
* Runs in the right order  
Place a step beneath another and it waits for it, so dependent work never races ahead.
* Branches stay independent  
Separate paths advance side by side, so unrelated steps never wait on each other.
* Waits without cost  
A step can pause for days before it runs, and a parked flow costs nothing while it sits and waits.
* Logic too specific to click  
When a rule is too particular for any dropdown, write it in Flexie Scripting, right in the step.

[Read Passing Data docs](https://flexie.io/resources/workflows/passing-data-between-steps)

AI inside the flow

## Rules when you want them. Judgment when you don't.

A plain automation follows fixed rules, and most of the time that is exactly right. But some steps need real judgment: read this message and draft a reply, review this deal and flag the risks, summarize what happened today. Flexie lets you drop the AI in as a step, give it the job in plain words, and it does that job every time the flow runs, unattended, for the whole business.

* AI as a step  
Hand any step to Flexie AI in plain words, and it does that job each time the flow runs.
* Thinks, not just follows  
Read, draft, classify, summarize, the parts a fixed rule could never handle on its own.
* Or let AI build the flow  
Describe the automation you want and Flexie AI assembles the whole thing, ready to review and switch on.
* Its output flows on  
What the AI produces becomes data the next steps use, to send, to branch, or to update a record.
* Approval on what matters  
Anything material still pauses for a yes before it happens, the same as everywhere in Flexie.
* Your vendors, your models  
Runs on your own AI accounts, with the right model picked for each job, so it stays efficient and never locks you in.

[Read about Flexie AI](https://flexie.io/resources/ai/overview)

Built to be trusted

## Industrial-grade, not a weekend toy.

An automation is only worth setting up if you can trust it on your busiest day and change it without fear. Flexie runs thousands of records through a flow at once, parks the ones that are waiting so they cost nothing, retries what it safely can, and writes down every step it takes. You test a flow on a real record before it goes live, and roll any change back in a click.

* Runs in parallel  
Thousands of records move through a flow at once on a pool of workers, so a quarter-end rush never becomes a backlog.
* Test before it is live  
Run the whole flow against one real record and see what every step would do, before a single message goes out.
* A full audit trail  
Every step writes a log row, with its result and the reason it failed, so nothing a flow did is a mystery.
* Roll back in a click  
Every save is a version, so if an edit misbehaves you restore the last good one instantly.

What teams automate

## The work that used to eat your week.

Six processes businesses hand to Flexie and stop thinking about, each built once the way it actually works.

Sales

### Never drop a lead

Every inbound lead is scored, assigned to the right rep, and answered before anyone has even opened it.

Lead scoringRouting

Finance

### Chase overdue invoices

Gentle reminders send themselves on a schedule until the bill is paid, then stop on their own.

DunningScheduled

Customer success

### Onboard like clockwork

Every new customer gets the same welcome, tasks, and checklist the moment the deal is won.

OnboardingTasks

Retention

### Renew without the scramble

A subscription coming due triggers the renewal note weeks ahead, and escalates if a payment fails.

RenewalsWebhooks

Operations

### Keep records clean

Duplicates are caught on creation, stale leads archive after 90 days, missing fields fill themselves in.

Data hygieneLists

Support

### Escalate the right tickets

An SLA about to breach routes to a manager, a VIP ticket pages on-call, and the rest group by topic.

EscalationDecisions

Plain speak

## A real automation engine, not a few canned rules. Know which you need.

Flexie automates the complex, multi-step processes your business runs on. That is power for teams with real workflows to capture, and more than teams who just need a couple of simple alerts.

### Where Flexie automation fits

* You have multi-step processes that span sales, billing, support, and messaging.
* You want each automation built the way your business runs, not forced into a fixed template.
* You need flows that branch on your own rules and treat your biggest accounts differently.
* You want to reach customers on email, SMS, and WhatsApp from your own accounts.
* You want some steps to use real judgment, drafting, classifying, summarizing, with AI.
* You need to trust automations on a busy day and change them without fear.

### Where it is not the right tool

* You only need one or two simple alerts and nothing more.
* You want a fixed library of pre-built recipes and no process of your own to capture.
* You are not ready to map how your processes actually run before automating them.
* Your tools have no events, messages, or webhooks for a flow to react to.
* You want a single toggle and never to think about the process behind it.
* Your needs are simple and a stock tool's built-in rules already cover them.

## Give your team back its week.

Explore the live demo to build a flow and watch it run, or book a call. We will map one of your processes with you, show you the shortest path to automate it, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Compare Flexie

Source: https://flexie.io/compare

Compare

# Flexie next to the tools you know.

Most of these tools are genuinely good, and for plenty of teams one of them is the right call. This is not a scoreboard where Flexie wins every row. For each platform, here is what it does well, the real difference in shape, and when you should pick it over Flexie, or Flexie over it. If another tool fits you better, we will say so.

[HubSpot](#hubspot)[Salesforce](#salesforce)[Microsoft Dynamics 365](#microsoft-dynamics)[Zoho](#zoho)[Monday.com](#monday)[Bitrix24](#bitrix24)[Odoo](#odoo)[Pipedrive](#pipedrive)[Freshworks](#freshworks)[Creatio](#creatio)[SugarCRM](#sugarcrm)[Airtable](#airtable)[Attio](#attio)[Keap](#keap)

Marketing & sales CRM

## Flexie vs HubSpot

A polished, marketing-led CRM suite built around inbound.

Where HubSpot shines. HubSpot is hard to beat for inbound marketing. The content, email, and campaign tools are best in class, the interface is genuinely pleasant, and the academy and app marketplace get a team productive fast. For a marketing-led company, it is one of the safest picks on this list.

The key difference. The shape and the bill. HubSpot is a set of Hubs sold per seat, with the features you want often sitting one tier up, so cost climbs as your contact list and team grow. Flexie is one programmable engine with flat platform pricing: a one-time setup and then an ongoing subscription that does not climb as you add people, no per-seat fees and no tier gates. You shape your own records, pipelines, billing, and support on the same data instead of staying inside the CRM's assumptions.

Choose HubSpot when

Your growth is marketing-led, inbound content and email sit at the center of how you sell, and you want world-class marketing automation out of the box.

Choose Flexie when

Your work spans sales, billing, support, and operations with non-standard logic, and you want it shaped to your data without per-seat fees or tier gates, with an AI workforce acting under your approval.

Enterprise CRM platform

## Flexie vs Salesforce

The enterprise CRM standard, endlessly extensible.

Where Salesforce shines. Salesforce sets the ceiling for what a CRM can become. The platform extends to almost any requirement, the AppExchange ecosystem is enormous, and the talent pool to build on it is deep. For large, complex enterprises, very little else reaches as far.

The key difference. What that reach costs. Salesforce typically means per-seat licensing, admins, and consultants to realize and maintain, and the total grows with every requirement. Flexie reaches much of that flexibility through one programmable engine: a one-time setup shapes it to you, then your own team adjusts it on point-and-click screens. You pay once for that setup and an ongoing subscription for the platform, with no per-seat licensing and no standing admin team to fund.

Choose Salesforce when

You are a large enterprise that needs the deepest ecosystem and integrations, and you have, or can fund, the admin and consultant resources to run it.

Choose Flexie when

You are mid-market and want enterprise-grade flexibility shaped to your business, without enterprise pricing, seat counts, or an admin army.

Enterprise business apps

## Flexie vs Microsoft Dynamics 365

Microsoft's enterprise CRM and ERP, deep in the Microsoft stack.

Where Microsoft Dynamics 365 shines. Dynamics 365 is a serious enterprise suite, and it is at its best when you are already committed to Microsoft. The ties into Office, Teams, Power Platform, and Azure are tight, and the combined CRM and ERP reach suits large, process-heavy organizations.

The key difference. Independence and weight. Dynamics rewards going all-in on Microsoft and usually involves per-user licensing and a partner to implement. Flexie is independent of any one stack, set up around your processes once and then lighter for your team to run day to day, on flat platform pricing with no per-user licensing to manage.

Choose Microsoft Dynamics 365 when

You are standardized on Microsoft, want tight Office, Teams, and Power Platform integration, and have enterprise ERP needs.

Choose Flexie when

You want a stack-independent platform shaped to your processes, without per-user licensing or tying your operations to one vendor's ecosystem.

All-in-one app suite

## Flexie vs Zoho

A remarkably broad, affordable suite of business apps.

Where Zoho shines. Zoho's value is hard to argue with. There is a Zoho app for almost everything, the pricing is friendly, and for a cost-conscious SMB it covers an enormous amount of ground for very little money.

The key difference. One engine versus many apps. That breadth is a large family of separate applications sharing a login and brand, so workflows that cross apps can get stitchy. In Flexie, CRM, billing, support, and reports run on the same data and the same scripting language, so a process that spans them behaves as one system rather than several handing off to each other.

Choose Zoho when

You want broad, inexpensive coverage of fairly standard needs and are comfortable with separate apps and light cross-module logic.

Choose Flexie when

Your processes cross modules and need to behave as one system on shared data, with custom records and logic, not several apps wired together.

Work OS and no-code boards

## Flexie vs Monday.com

A friendly, board-based Work OS for teams.

Where Monday.com shines. Monday.com makes getting started genuinely easy. The colorful boards are approachable, non-technical teams adopt them quickly, and for project and work management with light collaboration it is a pleasure to use.

The key difference. How far the boards go. Pushed toward CRM, billing, or support, Monday becomes boards plus bolted-on apps, and the depth tops out against a real runtime. Flexie runs CRM, billing, and support natively on one engine and one scripting language, so you grow your actual workflow instead of stacking add-ons onto boards.

Choose Monday.com when

Your core need is project and work management with visual collaboration, and a lightweight CRM on boards is enough.

Choose Flexie when

You need real CRM, billing, support, and automation with custom logic on shared data, not boards extended with apps.

All-in-one business suite

## Flexie vs Bitrix24

A broad all-in-one business suite with a generous free tier.

Where Bitrix24 shines. Bitrix24 packs an impressive amount into one place, from CRM to collaboration to built-in telephony, and the free tier lowers the bar to entry about as far as it goes. For teams that want a lot of modules without paying much, it delivers.

The key difference. Coherence. That breadth is many modules bundled together, and once you need them to work as one tailored system the seams and complexity show. Flexie is one coherent runtime you shape to your real records and pipelines, so the parts share one data model and one logic layer rather than sitting side by side.

Choose Bitrix24 when

You want a wide module set cheaply or free, and standard configurations cover your needs.

Choose Flexie when

You need a coherent, deeply shaped system with custom records, custom logic, and an AI workforce, not a broad pack of modules.

Open-source business suite

## Flexie vs Odoo

A broad open-source ERP suite, with CRM as one module.

Where Odoo shines. Odoo's real strength is integrated ERP breadth: finance and accounting, inventory, manufacturing, and operations in one open-source system, at an entry price that is hard to beat. Accounting in particular is a standout, and it is a common reason teams adopt it. Sales and CRM are part of the suite and gain from sitting next to stock and finance, but here Odoo is broad rather than deep, since tools built for CRM go further on sales and customer engagement. With the technical resources to build and host it, you can take Odoo a long way and own the code.

The key difference. Assemble-and-host versus set-up-with-you. Odoo asks you to assemble modules and, in practice, to self-host and treat real customization as a development project, and its depth sits in finance and operations rather than in the customer-facing side. Flexie is a managed engine, set up with you once and then adjusted by your team on point-and-click screens, and it goes deep on the CRM and the day-to-day processes around it, shaped to how you actually work, without standing up infrastructure or a dev team to maintain it.

Choose Odoo when

You need open-source ERP breadth, especially accounting, finance, and inventory in one system; you have the dev and IT resources to build and host; and owning the code matters to you.

Choose Flexie when

You want a CRM and the processes around it shaped to how you work, managed and adjusted on point-and-click screens, without assembling modules, hosting servers, or running a development team.

Sales CRM

## Flexie vs Pipedrive

A clean, focused sales pipeline CRM.

Where Pipedrive shines. Pipedrive does one thing very well: moving deals through a pipeline. It is fast to adopt, salespeople actually like using it, and for a deal-centric sales team it stays out of the way and keeps the funnel moving.

The key difference. Scope by design. Pipedrive deliberately focuses on the sale, so billing, support, and operations live in other tools. Flexie keeps the whole lifecycle in one place: the same engine that runs your pipeline also runs invoicing, support cases, automation, and a public API, so the work after the deal lives in the system too.

Choose Pipedrive when

You want a simple, excellent tool for the sales pipeline and are happy handling everything after the sale elsewhere.

Choose Flexie when

You want the sales pipeline plus everything that follows it, billing, support, automation, and integrations, as one shaped system.

CRM and support suite

## Flexie vs Freshworks

A family of approachable sales and support products.

Where Freshworks shines. Freshworks builds polished, approachable software. Freshsales and Freshdesk are quick to pick up, the design is clean, and teams that want a strong standalone sales or support tool get productive fast.

The key difference. A suite of products versus one runtime. Freshworks is several products, generally priced per product and per seat, and the depth across them varies. Flexie is a single runtime where sales, support, billing, and automation share one data model, on one flat platform subscription with no per-seat fees, so you shape one system instead of subscribing to several.

Choose Freshworks when

You want strong standalone sales or support tools with approachable UX, and per-product, per-seat pricing suits you.

Choose Flexie when

You want sales, support, billing, and operations as one shaped engine on one flat subscription, not separate products each with their own bill.

Low-code CRM and process automation

## Flexie vs Creatio

An enterprise low-code platform with strong process automation.

Where Creatio shines. Creatio is the closest on this list in spirit. It pairs genuine low-code with serious process automation and business process management, and it is enterprise-capable. If you respect what Flexie is trying to do, you will respect Creatio.

The key difference. The commercial model, more than the ambition. Creatio is generally licensed per user and positioned for enterprise builds. Flexie has no per-seat fees: a one-time setup builds it around you, your own team then adjusts it directly, and the platform itself is a flat ongoing subscription, with an AI workforce running the day to day under approval.

Choose Creatio when

You have enterprise, process-heavy requirements and want an established low-code platform with a per-user model and a partner ecosystem.

Choose Flexie when

You want comparable shaping power without per-seat pricing, with the build done with you and an AI workforce operating inside it.

Traditional CRM

## Flexie vs SugarCRM

A mature, deeply customizable traditional CRM.

Where SugarCRM shines. SugarCRM has been customized to fit demanding sales organizations for years, and it shows. The data model is flexible, the customization runs deep, and an on-premises option is there if you need it.

The key difference. How change happens. With Sugar, deep customization tends to be a developer-driven project, so each change waits in a queue. Flexie is shaped on point-and-click screens after the initial build, with an AI workforce that runs it, and it brings billing, support, and automation onto the same engine rather than leaving them to other systems.

Choose SugarCRM when

You want an established CRM with very deep customization and you have the developer resources to drive it.

Choose Flexie when

You want deep shaping without queuing every change as a development project, plus billing, support, and automation in one engine.

Flexible database and work tool

## Flexie vs Airtable

A powerful, flexible database and builder.

Where Airtable shines. Airtable is a superb flexible database. You can bend it into almost any structure, the interface is approachable, and for custom internal tools and lightweight apps it is one of the most capable building surfaces around.

The key difference. Building blocks versus a running platform. Airtable hands you the pieces to assemble, so a CRM, billing, support, or telephony setup is something you build or integrate. Flexie ships those already running from day one, on your own channels, set up with you once, so you start with a working business platform rather than a kit.

Choose Airtable when

You want a flexible database and builder for custom internal tools, and you are happy assembling the pieces yourself.

Choose Flexie when

You want a ready-to-run business platform, CRM, billing, support, and your own telephony, shaped to you rather than built from blocks.

Modern AI-native CRM

## Flexie vs Attio

A sleek, AI-native modern CRM.

Where Attio shines. Attio is a genuine pleasure to use. It is modern, fast, AI-native, and beautifully designed, and for startups and relationship-led teams that want a CRM that feels current, it is an easy one to love.

The key difference. A CRM versus an operating system for the business. Attio is, at heart, about relationship data, so billing, support, telephony, and operations sit outside its scope. Flexie runs CRM alongside billing, support, telephony, and automation on the same data and scripting, on your own channels, with no per-seat fees.

Choose Attio when

You want a beautiful, modern CRM focused on relationships and data, and a startup-friendly experience.

Choose Flexie when

You need CRM plus the operational stack, billing, support, telephony, and automation, shaped and running as one system.

SMB CRM and automation

## Flexie vs Keap

An SMB sales and marketing automation CRM.

Where Keap shines. Keap is a dependable choice for small businesses that want sales and marketing automation working quickly. The templates get a service business up and running fast, and for standard SMB flows it does the job without much setup.

The key difference. Templates versus a programmable engine. Keap shines on standard, out-of-the-box flows and gets tighter the further your process strays from them. Flexie is an engine you mold to your own records and logic, with an AI workforce acting under your approval, so non-standard processes are the normal case rather than the hard one.

Choose Keap when

You are a small business that wants quick, out-of-the-box sales and marketing automation on fairly standard flows.

Choose Flexie when

Your processes are non-standard and you need to shape records and logic with an AI workforce, beyond what templates allow.

## Not sure which one fits you?

Book a call and we will look at how your business actually works, then give you an honest answer on whether Flexie is the right fit, or point you to a tool that is.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Contact Flexie

Source: https://flexie.io/contact

Contact

# Talk to us.

We'd rather have an honest conversation than push a sale. Tell us what you're trying to do, and we'll point you in the right direction, with an honest take on whether Flexie fits.

Tell us about your business

## Tell us what you're working on.

A few details, plus a couple of lines about your use case, so we come to the conversation prepared. We aim to reply within one business day.

First name \*Last name \*

Phone number \*Business email address \*Enquiries using public email addresses like @gmail.com may not receive a response.

Your main goal? \*

Choose an optionFix company chaosBetter finance flowBetter billing/subscriptionsBuild internal processesBuild marketing workflowsHandle customer supportAI related workflowsBoost sales team productivityMaking this the core of my startupPretty much all and moreJust a simple CRMI'm not sure, it's dynamic

Your industry \*

Choose an optionMarketing AgencyReal EstateHuman ResourcesFinancingInsuranceConsultingDistributionEducationTravel & HospitalityTransportationSoftwareGovernmentOther

What are you trying to solve? \*A few lines about your use case or the problem you want to solve.I agree to receive communications from Flexie, which may include phone calls, emails, and SMS, and I can opt out at any time via the unsubscribe link in any email. I have read and agree to the [Terms of Service](https://flexie.io/terms) and [Privacy Policy](https://flexie.io/privacy-policy).

Start the conversation

Or email directly

### Sales

Pricing, demos, on-premises quotes, multi-team rollouts.

[sales@flexie.io](mailto:sales@flexie.io)

### Support

If you're already a customer and need help, this is the fastest path.

[support@flexie.io](mailto:support@flexie.io)

### Partnerships

Resellers, integrations, agencies, technology partners.

[partners@flexie.io](mailto:partners@flexie.io)

### Where we are

Based in Innsbruck, Austria. We serve customers worldwide.

---

## Cookie Policy

Source: https://flexie.io/cookie-policy

Legal

# Cookie Policy

Effective date: 10 May 2026

## This website is cookieless

The Flexie website (flexie.io) **uses no cookies**. We do not set our own cookies, and we do not load third-party cookies, tracking pixels, advertising tags, fingerprinting, or social-media trackers. Nothing is stored on or read from your device for tracking, and we do not build any profile of you.

## No tracking, no cross-site tracking, no ads

We do not use tracking or advertising cookies, we do not track you across other websites, and we do not sell or share your browsing activity for advertising. Your language choice is kept only in the page address (URL), not in a cookie or in your browser's storage.

## Analytics, without cookies

To understand at an aggregate level how the website is used, we use **Umami**, a privacy-friendly web-analytics tool that is **cookieless**. It stores nothing on your device and does not identify you. It records only anonymous, aggregated information such as which pages are visited, the referring website, approximate country, and the browser or device type. It does not track you across other sites and does not build a personal profile. Because it sets no cookies and processes no personal profiles, no cookie banner is required. See the [Privacy Policy](https://flexie.io/privacy-policy) for details and the legal basis.

## The Flexie CRM application

This Cookie Policy covers the public flexie.io website. The Flexie CRM application (the logged-in product) is separate and may use **strictly necessary** cookies, for example to keep you signed in and to protect your session. Those are required for the Service to work and are not used for tracking, analytics, or advertising.

## Customer-configured technologies

Customers may configure their own integrations, tracking, analytics, pixels, or scripts inside their Flexie CRM account or workflows. The customer is responsible for those technologies and for any notices, consent, and legal basis they require. They are not Flexie-controlled cookies merely because the Service provides the tooling.

## Changes and contact

We will update this page if our use of cookies ever changes. Questions about cookies may be sent to [support@flexie.io](mailto:support@flexie.io).

---

## Data Retention Policy

Source: https://flexie.io/data-retention-policy

Legal

# Data Retention Policy

Effective date: 10 May 2026

## 1\. Scope

This policy describes how Flexie retains and deletes data in connection with the Flexie CRM website, accounts, support, billing, security operations, and the CRM Service.

## 2\. Customer CRM Data

Customer CRM data is retained during the active subscription term unless Customer deletes it earlier using available Service functionality or instructs Flexie otherwise. Customer controls the data it enters into the Service and is responsible for configuring its own retention, deletion, export, and workflow rules where available.

## 3\. Termination and Export

After termination or expiry of the Service, Flexie may make Customer CRM data available for export for a reasonable period, unless otherwise agreed. After that period, production data may be deleted, disabled, or made inaccessible, subject to backup rotation, legal obligations, dispute resolution, security, or abuse-prevention needs.

## 4\. Backups

Backup copies may remain for a limited period until overwritten or deleted through normal backup rotation. Backup data is protected and is not restored into production except for disaster recovery, security, legal compliance, or operational continuity purposes.

## 5\. Logs and Security Records

Application logs, audit logs, access logs, security logs, workflow execution logs, and diagnostic records may be retained for security, troubleshooting, abuse prevention, compliance evidence, and service reliability. Retention periods may vary depending on the type of log, customer configuration, legal requirements, and operational needs.

## 6\. Account, Billing, Business, and KYC Records

Account administration, invoices, accounting records, tax records, business correspondence, contract records, and identity verification / Know Your Customer (KYC) records may be retained for the period required by applicable law, including Austrian accounting, tax, and AML/CTF retention rules, and for the establishment, exercise, or defence of legal claims.

## 7\. Support Data

Support tickets, support emails, attachments, troubleshooting details, and related communications are retained as necessary to provide support, maintain service history, resolve disputes, improve security, and comply with legal obligations. Customers should avoid sending unnecessary sensitive data to support channels.

## 8\. Website and Cookie Data

Website logs and cookie data are retained according to their purpose, the cookie settings selected by the visitor, legal requirements, and operational needs. Non-essential cookies should not be retained longer than necessary for their stated purpose.

## 9\. Customer-Configured Integrations

Data transmitted to external systems through Customer-configured integrations is controlled by Customer and the external service selected by Customer. Flexie does not control retention by those external systems unless Flexie has separately contracted them for the core Service.

## 10\. AI-Related Data

Where Customer configures AI/API integrations or AI-related workflows, Customer is responsible for determining what data is sent, which fields are excluded, and how long the external AI provider or endpoint retains data. Flexie does not use Customer Personal Data to train general-purpose AI models or third-party AI models unless separately agreed in writing.

Where Customer's use of the Service involves a high-risk AI system under Regulation (EU) 2024/1689 (EU AI Act), Customer is responsible for the record-keeping, logging, and retention obligations imposed on deployers and other operators of high-risk AI systems under Article 19 and related provisions of the EU AI Act. Flexie's standard retention of platform logs is not a substitute for those obligations.

## 11\. Deletion Requests

Requests relating to Customer CRM data should normally be handled by the Customer as controller. Where Flexie acts as controller, deletion requests may be sent to [support@flexie.io](mailto:support@flexie.io). Flexie may refuse or limit deletion where retention is required by law, contract, security, backup integrity, dispute resolution, or legitimate business needs.

## 12\. Legal Holds

Flexie may retain data beyond standard periods where necessary for legal claims, regulatory requests, investigations, fraud prevention, security incidents, or to comply with applicable law.

---

## FAQ

Source: https://flexie.io/faq

FAQ

# Questions, answered.

The things most people want to know before getting started. Don't see your question? [Ask us directly.](https://flexie.io/contact)

## The basics

What exactly is Flexie?

Flexie is an all-in-one business platform: CRM, sales pipelines, support cases, marketing campaigns, invoicing, and workflow automation in a single product. It's designed for companies that want one system instead of stitching together six.

Is Flexie a CRM, or something more?

Both. The CRM is the foundation (contacts, accounts, deals, cases), but the platform extends into quoting, invoicing, subscriptions, multi-channel inbox (Email, SMS, WhatsApp), reporting, and an AI Agent that can act on your data.

Who is Flexie a good fit for, and who isn't it for?

Flexie fits businesses whose processes don't fit a generic tool: several pipelines, real exceptions, and billing, support, and outreach that all have to talk to each other. It's less of a fit if your needs are simple and a basic off-the-shelf CRM would do, and we'll say so. We'd rather point you to a lighter tool than sell you more than you need.

## What Flexie does

Can I call and message customers from inside Flexie?

Yes. Flexie has a built-in phone (powered by Twilio or your own FreePBX or Asterisk) with a softphone, call logs, and recordings, alongside a shared inbox for email, SMS, and WhatsApp. The channels stay yours: your numbers and provider accounts, your conversation history, each message linked to the right record automatically.

Can Flexie handle quotes, invoices, and recurring billing?

Yes. Quotes, orders, invoices, and subscriptions live in the same system as your sales and support, so nothing has to sync between separate tools. Recurring invoicing and native auto-billing run in the platform's billing engine, and payments work with your own card processor rather than locking you to one.

Does Flexie do automation?

Yes, visually, with branching logic, schedules, and triggers from records, inbound messages, or external webhooks. Workflows handle lead routing, follow-up sequences, case escalation, renewals, and data hygiene. AI Agents extend this with natural-language commands.

Can I customize Flexie to my business?

Heavily. Add custom entities, custom fields, custom pipelines, custom dashboards, custom PDF templates, custom forms. The platform was built for businesses whose processes don't fit a generic mold.

What integrates with Flexie?

Email (Gmail, Outlook, any IMAP/SMTP), SMS providers (Twilio, Sakari, GoIP), WhatsApp Business, calendar systems, and anything else through webhooks or our REST API. There's also an MCP server so AI tools can read and write Flexie data directly.

Can I migrate from another CRM?

Yes. We import contacts, accounts, deals, and history from CSVs or directly from major CRM platforms. Custom fields and pipelines are mapped during onboarding. For complex migrations, our team can handle it as a managed service.

## AI and developers

What can Flexie's AI Agents actually do?

More than chat. Flexie's AI Agents work on your data with real tools: reading and updating records, drafting and sending messages, moving deals, creating tasks, and triggering workflows. They carry the context of your setup across sessions, and for anything material they ask for approval before they act. You point one at a process and it works it like a teammate, not a chatbot bolted on the side.

Do I have to pay for the AI separately, and whose models does it use?

Flexie is vendor-independent: you connect your own AI provider and choose your own models, and you pay that provider directly. Your vendor, your models, your bill, never the platform's. There's no lock-in to one AI company, and you can move to better models as they arrive.

Can developers extend Flexie?

Yes. Beyond point-and-click customization, Flexie exposes a REST API and webhooks, an MCP server so AI tools can read and write your data directly, and a built-in scripting layer for logic that goes past the standard screens. The same engine runs every part of the product, so what you build composes with everything else.

## Your data and deployment

Is my data locked in? Can I get it out?

Your data is yours. You can export it whenever you want, and on-premises you keep it on your own servers entirely. If Flexie ever stops being the right fit, you leave with everything we hold for you, no hostage-taking.

Can I deploy Flexie on my own infrastructure?

Yes. Flexie runs as a managed cloud service or on your own servers (on-premises or your private cloud: AWS, GCP, Azure). On-prem customers get the same product and updates, with full control over data residency.

What about data security and compliance?

Encrypted at rest and in transit, role-based permissions down to the field level, full audit trail of every change, and passwordless magic-link login as an option. On-prem deployments keep data inside your perimeter.

## Pricing and getting started

How does pricing work?

One platform, one offer: you get every module for your whole team, with no per-user fees and no features locked to a higher tier. Getting started includes a one-time implementation tailored to your business, billed once, and we quote a fair price after a short consultation instead of posting a sticker price that's wrong for most people. The pricing page lays out the full model.

How long does it take to get started?

It depends on how much we tailor to your business. The platform ships with sales, support, billing, and marketing modules ready to use, and the one-time implementation configures the fields, pipelines, and workflows around how you actually work. Simpler setups move fast; more complex businesses take a bit longer, and we scope that with you up front.

Do you offer support?

Yes, from real people, and it's included for everyone. There are no support tiers to climb and no paying extra to reach a human. Onboarding help is part of getting started, and we stay reachable after that.

Can I try Flexie before committing?

Yes. There's a live demo workspace you can open right now, with no signup and no credit card, so you can explore the full product before you ever talk to us. When you're ready, a free consultation gets you a straight quote.

## Still have questions?

Book a call and we will look at how your business actually works, and tell you honestly whether Flexie is the right fit. Or open the live demo and explore it on your own.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## How Flexie Works

Source: https://flexie.io/how

How it works

# From first call to daily operations

Flexie is set up around your business once, then your team runs it, with an AI workforce handling the tasks they hand off. Here is the concrete path, from the first call to the day-to-day.

Step 01

## Consultation

A working call to understand your business and agree on scope.

* Walk through your current tools and where your data lives
* Map the records, fields, and pipelines you actually use
* List the workflows, channels, and integrations you need
* Agree on scope, and whether Flexie fits the job

Step 02

## Implementation

We configure the platform around your business, for a one-time setup fee.

* Model your records, fields, pipelines, and dashboards
* Migrate your existing data into Flexie
* Build the workflows that run your repeatable work
* Scope, timeline, and price agreed before the build

Step 03

## Connect channels and systems

Your communication and your existing software, wired in.

* Email, calls, SMS, and WhatsApp on your own accounts
* Inbound messages routed to the right records, one inbox
* Existing systems connected over the REST API and webhooks
* Your own endpoints where another system pushes data in

Step 04

## Onboard your team

Your people come in with the right access and learn the system they run.

* Create accounts and set roles and permissions per person
* Match what each person sees and can do to their job
* Train the team on the pipelines and inbox they use daily
* Your people run the operation, AI assists where you set it

Step 05

## Set up the AI workforce

AI handles the repetitive tasks your team hands it, inside your processes.

* Add your own AI vendor accounts, billed to you
* Configure experts, each with its own model and instructions
* Decide which tasks run by AI and which stay with people
* AI steps run inside workflows, with approval gates

Step 06

## Run it and adjust

Your team runs the day to day, and you adjust the setup as you go.

* Your team runs sales, support, and billing in one place
* Make routine changes from point-and-click screens
* Tweak pipelines, fields, and dashboards yourself
* Use Flexie Scripting for deeper, custom logic

What it costs

## Two parts, both agreed up front.

There is no sticker price, because the right setup and platform depend on your business. After the free consultation we give you a straight quote, and nothing is billed until you agree to it.

One-time

### Setup fee

A single fee for the implementation: configuring the platform around your business, migrating your data, and building your workflows. Billed once, not every month.

Ongoing

### Platform subscription

A recurring subscription for the platform, billed monthly, quarterly, or annually, whichever suits you. Flat pricing for your whole team, with no per-seat fees.

Both are set with you after the free consultation, and agreed before any work starts.

## See how it maps to your business.

Explore the live demo to click through a real workspace, or book a call. We'll map how your business runs, walk the path from setup to day-to-day, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Imprint

Source: https://flexie.io/imprint

Legal

# Imprint

Effective date: 10 May 2026

## Service Provider / Media Owner

**Flexie CRM e.U.**  
Operated by Eriol Gjergji  
Registered sole proprietorship  
Fritz-Konzert-Strasse 7, Top 1/3  
6020 Innsbruck  
Austria

Phone: [+43 676 4265955](tel:+436764265955)  
Email: [support@flexie.io](mailto:support@flexie.io)  
Website: <https://flexie.io>

## Business Information

Business purpose: Software and IT services  
UID/VAT number: ATU81616707  
Company register number (Firmenbuchnummer): FN 679939 k  
Register court (Firmenbuchgericht): Landesgericht Innsbruck  
Member of: Wirtschaftskammer Österreich (WKÖ) / Wirtschaftskammer Tirol  
Applicable professional/trade law: Austrian Trade Regulation Act (Gewerbeordnung, GewO)

**Supervisory / trade authority:**  
Stadtmagistrat Innsbruck  
Maria-Theresien-Strasse 18  
6020 Innsbruck, Austria

## Online Presences

This imprint also applies to Flexie's official online presences, including LinkedIn company profiles and other official Flexie CRM business profiles where legally applicable.

## Responsible for Website Content

Eriol Gjergji  
Fritz-Konzert-Strasse 7, Top 1/3  
6020 Innsbruck, Austria

## Liability for Website Content

We make reasonable efforts to keep the information on this website accurate and up to date. However, we do not accept liability for the accuracy, completeness, or currentness of website content except where required by applicable law.

If you notice unlawful, incorrect, or problematic content, please contact us using the contact details above. We will review the matter and remove or correct content where legally required.

## Liability for External Links

This website may contain links to external websites operated by third parties. We are not responsible for external content. If we become aware of unlawful content on linked websites, we will remove the relevant links where legally required.

## Copyright

All content on this website, including text, images, graphics, logos, and other materials, is protected by copyright unless otherwise stated. Reproduction, distribution, or other use requires prior written permission unless permitted by law.

## Consumer Dispute Resolution

We are not willing or obliged to participate in dispute resolution proceedings before a consumer arbitration board.

The former European Commission Online Dispute Resolution platform has been discontinued and is therefore not linked here.

---

## Integrations & developer access

Source: https://flexie.io/integrations

Integrations & developer access

# Open to everything. Tied to no one.

Flexie is built to connect, not to fence you in. Your email, calls, and messaging run on your own provider accounts. Data flows in through secure endpoints and out through webhooks. A full REST API and an MCP server for outside AI agents put every record within reach, all under permissions you set.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

Runs on your own accountsEndpoints in, webhooks outA full REST APIOpen to outside AI agents

Channels

## Email, calls, and messaging on accounts you already own.

Flexie does not resell you a phone line or a mailbox. You connect the provider accounts you already pay for, your Gmail or IMAP, your Twilio, your WhatsApp Business number, your Stripe, and Flexie runs the conversations and payments through them. The data lands on the right record; the relationship with the vendor stays yours.

* Email, two ways  
Google, Microsoft, or any IMAP and SMTP mailbox, synced both ways, not just outbound.
* SMS and WhatsApp  
Send and receive on your own Twilio or WhatsApp Business number, attached to the customer.
* Calls on your line  
Telephony through Twilio or your own self-hosted PBX, with logs and recordings on the record.
* Calendars in sync  
Two-way with Google and Microsoft, so availability and meetings stay current.
* Payments you own  
Connect your Stripe or PayPal for invoice and subscription payments, reconciled in Flexie.
* Your vendor, your bill  
Every channel runs on your account, so you are never locked to a number Flexie controls.

[Read Inbox docs](https://flexie.io/resources/inbox/overview)

Data in

## A secure door for data to come in. Just a URL and a workflow.

When a website, an app, or a partner system needs to push data into Flexie, you give it a private endpoint. The moment something arrives, Flexie turns the request into a record and runs a workflow on it, looking things up, creating or updating records, replying to the caller. Often that is the whole integration, with nothing to build on the Flexie side.

* A URL, not a project  
Stand up a secure endpoint inside a workflow, in the visual builder. No servers to run, nothing to deploy.
* Turns requests into action  
Each incoming request becomes a record a workflow can read, decide on, and act on.
* Capture leads from anywhere  
Your website or landing page posts a form and a qualified lead lands in seconds.
* Receive any webhook  
A payment, an order, or a status change from another tool fires a flow the instant it arrives.
* Reply in the same call  
Return a response to the caller, so an endpoint can back a small custom API.
* Secured and controlled  
Authentication and cross-origin rules are handled for you, and you can switch it off anytime.

[Read Dynamic Endpoints docs](https://flexie.io/resources/dynamic-endpoints/overview)

Data out

## The moment something happens, your other tools know.

When a deal is won, an invoice is paid, or a record changes, Flexie can tell the rest of your software straight away. Webhooks push the event out with signed payloads, automatic retries, and a delivery log, so nothing has to be copied from one screen to another by hand.

* Fires on any event  
A new customer, a paid invoice, a won deal, any record change can trigger an outbound push.
* Keeps your tools in step  
Your accounting, data warehouse, or team chat hears about it the second it happens.
* Delivered, not dropped  
Failed deliveries retry on their own, and every attempt is logged for you to see.
* Plug into Zapier, Make, n8n  
Reach thousands of apps through the automation tool your team already uses.
* Signed and verifiable  
Payloads are signed, so the receiving system can trust the message really came from Flexie.
* Built from a workflow  
The same visual builder that runs your business decides what goes out and when.

[Read Integrations docs](https://flexie.io/resources/integrations/integrations-and-api)

Build on it

## Read and write every record. Build the connection you need.

When an off-the-shelf connector will not do, your developers get a full REST API over every record in Flexie, on standard authentication, with pagination and filtering. For logic too specific for any screen, they write Flexie Scripting and stand up their own endpoints, all without leaving the platform the rest of the team runs on.

* Every record, both ways  
Read and write leads, deals, invoices, cases, and your own custom records over one API.
* Standard, predictable auth  
Token authentication, pagination, and filtering work the way your developers expect.
* Your own endpoints  
Build custom HTTP endpoints inside Flexie, with auth and cross-origin already handled.
* Logic no dropdown holds  
When a rule is too specific to configure, write it directly in Flexie Scripting.
* Live answers, no extra storage  
Expose computed data as virtual records your systems can query like a table.
* Connect on your terms  
Run integrations on your own credentials and endpoints, never boxed into a vendor's list.

[Read Scripting docs](https://flexie.io/resources/flexie-scripting/overview)

AI Agents · MCP

## Hook your AI agents into Flexie's MCP server.

Flexie provides an MCP server, an implementation of the Model Context Protocol, the open standard for connecting AI to business software. Hook your AI agent into it and, just by asking, it can look up customers, pull reports, and trigger automations in Flexie, always inside the permissions of the person who connected it. This is on top of Flexie's own built-in AI workforce.

* A real MCP server  
Any MCP-compatible agent connects to it directly, so wiring one up is configuration, not a development project.
* Works on your real data  
An agent can look up customers, read reports, and start automations against your live workspace.
* Inside your permissions  
It only ever sees and does what the person who connected it is allowed to.
* Approvals still apply  
Anything material still asks for a yes before it happens, the same as everywhere in Flexie.
* On top of Flexie AI  
Separate from, and in addition to, Flexie's own AI workforce that runs inside the platform.
* Switch it off anytime  
See what is connected and revoke any agent's access in a single click.

[Read about Flexie AI](https://flexie.io/resources/ai/overview)

Before you integrate

## The best integration is the one you never have to build.

Most integrations exist to copy data between tools that do not talk to each other: the CRM, the billing tool, the help desk, the spreadsheet. In Flexie those are not separate tools. Sales, billing, communication, and support run on one engine, sharing one copy of every customer, deal, and invoice.

So before reaching for a connector, it is worth checking what already happens inside Flexie on its own. A won deal that raises an invoice, a paid invoice that closes a case, a message that lands on the right record, none of that needs an integration, because it never leaves the platform. The connections that remain are the few that genuinely reach outside, and those are what the rest of this page is for.

What teams connect

## Real connections, not a logo wall.

Six things businesses wire up with Flexie’s open model, every one built on the endpoints, webhooks, API, and channels above, not a marketplace of pre-canned apps.

Lead gen

### Website lead capture

A landing-page form posts to a dynamic endpoint, and the lead is scored, assigned, and answered before a rep ever opens it.

Dynamic endpointWorkflowsLead scoring

Finance

### Payment reconciliation

A Stripe webhook lands the moment a payment clears. Flexie marks the matching invoice paid and updates the balance to the cent.

StripeWebhooksFinance

Back office

### Accounting kept in sync

Won deals and paid invoices push out to your accounting tool, so the books match Flexie without anyone re-keying numbers.

WebhooksREST API

Operations

### Team chat alerts

When a big deal is won or an SLA is about to breach, a message posts to your team channel the second it happens.

WebhooksWorkflows

AI

### Outside AI agent

An AI agent your team already uses hooks into Flexie's MCP server to look up customers and pull reports, inside each person's permissions.

MCP serverPermissions

Developers

### Partner or mobile app

A partner portal or mobile app reads and writes records over the REST API, with its own endpoints for anything custom.

REST APIEndpointsScripting

Open, under control

## Opening Flexie up never means giving up control.

Every connection, whether it is another tool, a developer’s app, or an AI agent, gets only the access you grant it. Every request is checked against your permission rules. Anything material still asks for approval before it happens. And you can see what is connected and switch any of it off, the moment you want to.

* Granted, not assumed  
A connection only ever gets the access you give it, nothing more.
* Checked every request  
Each call is measured against your permission rules before it runs.
* Approval on what matters  
Material actions still pause for a yes, the same as everywhere in Flexie.
* Off in one click  
See everything that is connected, and revoke any of it instantly.

Plain speak

## An open platform, not a connector marketplace. Know which you want.

Flexie connects to almost anything through endpoints, webhooks, and an API, on your own terms. That is power for teams who want to own their integrations, and the wrong shape for teams who just want to pick an app from a list.

### Where Flexie’s open model fits

* You want your email, calls, and messaging to run on the provider accounts you already own.
* You have a website, app, or partner system that needs to push data into your CRM.
* You want other tools updated the instant something happens, not on a nightly export.
* You have developers who would rather build on a real API than wait on a vendor's roadmap.
* You want outside AI agents to reach your data safely, under your permissions.
* You would rather own and control your connections than rent them from a marketplace.

### Where it is not the right tool

* You want to browse a marketplace and switch on a pre-built app in two clicks.
* You have no one technical and need every integration fully managed for you.
* You only need a one-time CSV import, not a living connection between systems.
* Your other tools have no webhooks or API of their own to connect to.
* You want a single bundled price with every connector included and no setup.
* Your needs are simple and a stock tool's native integrations already cover them.

## Tell us what you need to connect.

Explore the live demo to see the inbox, endpoints, and API in a real workspace, or book a call. We will look at your stack, show you the shortest path to connect it, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## On-Premises Deployment

Source: https://flexie.io/on-premises

On-premises deployment

# Your data never leaves your own datacenter.

For governments and large organizations whose most critical data cannot leave their own datacenter, we deploy the full end-to-end Flexie platform on infrastructure you own. It integrates with the systems you already run, and can host frontier AI models on your own hardware, so even the AI stays inside your perimeter. You own the data. Flexie is only the software.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

Runs in your own datacenterIntegrates with your existing stackFrontier AI on your own hardwareYou own the data, not us

Data sovereignty

## The data lives where you do, and nowhere else.

On your own infrastructure, every customer, deal, invoice, and message stays inside your perimeter, in your country, under your jurisdiction. Nothing is copied to a vendor cloud, because there is no vendor in the path. The hosting providers behind the Flexie cloud are simply not part of an on-premises deployment. The only place your data lives is the place you put it.

* Stays in your perimeter  
Records never leave the network you run them on, so residency and jurisdiction are yours to set.
* No processor in the chain  
With nothing hosted by us, there is no third-party sub-processor touching your data at all.
* Your country, your rules  
Keep data inside the borders your regulator requires, on hardware your auditors can inspect.
* Run it on a closed network  
The core platform can run isolated, with no dependence on the public internet to operate.
* Yours to export and move  
Back it up, export it, and move it on your terms. It is your data, never ours to hold.
* Inspectable end to end  
Direct access to the database, files, and logs, so your team can verify exactly where everything sits.

[Read about security](https://flexie.io/resources/security/accounts-and-security)

Fits your stack

## It integrates end-to-end with the systems you already run.

An on-premises deployment is not an island. We integrate Flexie end-to-end with the infrastructure and software your organization already depends on: your ERP, your databases, your identity provider, your data warehouse, your internal and legacy systems, over connections that stay inside your network. The result is one platform that fits the way you already work, not another silo to keep in sync.

* Connects to your ERP  
Two-way links to the back-office systems you already run, so records and numbers stay in step.
* Reads your databases  
Pull from and write to the data stores your teams depend on, without exporting anything outside.
* Your identity provider  
Sign in through the directory your organization already uses, under your own access policy.
* Feeds your warehouse  
Send one clean, governed source of truth to the analytics and reporting stack you already have.
* Legacy and internal apps  
Endpoints, webhooks, and a full API connect the in-house tools no vendor catalog ever covers.
* Channels on your lines  
Calls, email, and messaging run on your own telephony and accounts, never on a vendor's.

[Read about integrations](https://flexie.io/resources/integrations/integrations-and-api)

Sovereign AI

## Frontier AI models, running on your own hardware.

When even AI inference cannot leave your walls, Flexie runs frontier models on the hardware you own. Your most sensitive data is reasoned over inside your datacenter, never sent to an outside provider. That same AI plugs deep into your real processes, so it can run them, improve them, and stand up autonomous agents that work unattended, all without a single token leaving your perimeter.

* Models on your GPUs  
Run frontier-grade models on your own accelerators, so every inference happens inside your datacenter.
* Nothing sent outside  
Your most sensitive data is reasoned over locally, never handed to a third-party AI provider.
* Deep process integration  
The AI works against your real records and workflows, not a sandbox bolted on the side.
* Autonomous agents  
Stand up agents that run whole processes unattended, on your data and under your rules.
* Improve and innovate  
Refine the processes you have and design better ones, with your own people in the loop.
* Approvals still apply  
Anything material still pauses for a human yes, the same safeguard as everywhere in Flexie.

[Read about Flexie AI](https://flexie.io/resources/ai/overview)

Runs on your terms

## It plugs into how your IT already runs.

An on-premises Flexie lives inside your operational world, not beside it. Sign-in, access, monitoring, and backups follow the controls your team already trusts. Updates happen on your change-control schedule, not ours. Your administrators hold the top-level access, and the activity record shows who did what, so nothing changes without a trace.

* Your access controls  
Roles and permissions decide who sees and does what, and changes take effect the moment you make them.
* Two-step sign-in  
Protect every account with a one-time code, so a guessed password is never enough on its own.
* Updates on your schedule  
Take new releases when your change-control process is ready, not when a vendor decides for you.
* Backups your way  
Snapshot, retain, and restore on the policy your operations team already runs.
* A full activity record  
Every important change is logged with who and when, ready for your own audits.
* Your administrators, your keys  
Your team holds the top-level access, on hardware only they can reach.

[Read Security docs](https://flexie.io/resources/security/accounts-and-security)

Ownership

## You own the data. Flexie is just the software.

That is the whole point of an on-premises deployment. The platform runs on your hardware, your data sits in your datacenter, and your team holds the access. We provide the software, and the people to stand it up and keep it running well, but the information itself is never ours to hold, move, or read. When the data is this critical, ownership is not a setting. It is the architecture.

* On your hardware  
The whole platform runs on infrastructure you own and operate, top to bottom.
* In your datacenter  
Data sits inside your perimeter, in the region your rules require.
* Under your access  
Your administrators hold the keys; we hold none you do not grant.
* Software, not custody  
We supply and support the software; we never become the keeper of your data.

Who runs it this way

## Built for data you cannot put on someone else’s cloud.

On-premises is for the organizations whose data is too sensitive, too regulated, or too critical to ever leave their own walls.

Public sector

### Government and public sector

Citizen records and case files kept on state-owned infrastructure, inside national borders, under public-sector audit.

Data residencyAudit

Finance

### Banking and finance

Regulated customer and transaction data held inside the institution's own controlled environment, on its own terms.

RegulatedControlled access

Healthcare

### Healthcare

Patient and clinical data kept under the provider's own custody and the compliance regime it already answers to.

Sensitive dataCustody

Defense

### Defense and critical infrastructure

Operations that demand isolated networks and infrastructure no outside party can reach or observe.

Isolated networkSovereign

Enterprise

### Large enterprises

Organizations with their own datacenters and security teams who standardize on infrastructure they fully control.

Own datacenterSecurity team

Telecom

### Telecom and utilities

Subscriber and network data at national scale, kept on the operator's own platform rather than a vendor's.

National scaleOperator-owned

Cloud or on-premises

## Most teams should start on the cloud. Some cannot.

The Flexie cloud is the right home for most businesses, faster to start and run for you. On-premises exists for the organizations whose data simply cannot live anywhere but their own datacenter. Same product, two homes.

Cloud

On-premises

Where data lives

Flexie cloud, EU region

Your own datacenter, your region

Runs on

Our managed infrastructure

Hardware you own and operate

Third-party processors

EU hosting providers

None in the chain

AI

Your own model accounts

Frontier models on your hardware

Your existing systems

Connected over the internet

Integrated inside your network

Updates

Handled for you

On your change-control schedule

Best for

Most businesses

Government and data-critical organizations

## Talk to us about a deployment.

Tell us about your data, your regulators, and the environment it has to run in. We will walk your IT and security teams through how an on-premises Flexie is stood up, and tell you honestly whether the cloud would serve you better.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Platform

Source: https://flexie.io/platform

The Flexie platform

# Built for businesses that don't fit in a tile.

Sales, money, customer conversations, automation, AI, and the build layer underneath, every surface running on one engine, shaped to how your business actually works. One platform underneath, not a stack of separate tools stitched together.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

One engine for every surfaceShaped, not configuredProgrammable, when you need itBuilt for real complexity

Sell

## Sell the way your team already sells, not how a tool dictates.

Pipelines that bend to your stages, not the other way around. Fields that change per stage. Quotes that morph into invoices without retyping. Forecasts built on real history, not optimism.

* Multi-pipeline records  
Separate pipelines per segment, stage-specific fields, no template lock-in.
* Lead scoring you can explain  
Every score traces back to rules you set point-and-click, so you always know why a lead ranks where it does.
* Quote → Invoice → Payments  
A won deal flows straight into billing, quote to invoice to payment, the same numbers carried through with nothing retyped.
* Forecasts on real data  
Driven by stage probability, value, and your actual win history.
* Internal forms for any process  
Run any internal process or business rule through a form you build point-and-click, not just approvals.
* Activity timeline  
Every email, call, SMS, and field change on the contact, in order.

[Read CRM docs](https://flexie.io/resources/crm/deals-and-pipelines)

Get paid

## Real billing isn't one quote, one invoice, one payment.

A real deal rarely settles in one clean step. One quote splits into a deposit, milestones, and a balance. Each invoice gets paid in parts, on different dates, sometimes in different currencies. Flexie tracks every cent and every due date with the same math, so your books always reconcile and nothing slips past its timing.

* One quote, many invoices  
Split a quote into a deposit, milestones, and a balance, each its own invoice on its own due date.
* Many payments per invoice  
Part-payments and installments post to the right invoice, and the outstanding balance updates to the cent.
* Recurring billing  
Fixed plans, metered usage, or a mix. Cycles, prorations, and upgrades worked out for you.
* Dunning that reads the timing  
Reminders escalate by how late a payment is and by channel. A 30-day nudge isn't a 90-day demand.
* Multi-currency and tax  
Applied per line item, with VAT and FX handled as you go, not patched on at the bottom.
* Reconciled to your books  
Every payment matched to its invoice line and exported clean, VAT and FX already applied.

[Read Finance docs](https://flexie.io/resources/finance/overview)

Talk

## Every conversation, linked to the right record.

Email, SMS, WhatsApp, and calls land in one place, then auto-link to whatever record they belong to: a lead, a contact, an account, or a custom record you defined. Matched by email or phone, attached to every match, so a conversation always sits on the right timeline and nothing gets lost.

* Auto-linked to records  
Matched by email or phone to leads, contacts, accounts, or any custom record, so context is never orphaned.
* One view, all channels  
Email, SMS, WhatsApp, and calls in a single view, not four apps to tab between.
* Per-user access  
Each user sees the mailboxes, SMS lines, and WhatsApp numbers they are granted, nothing more.
* Email with full sync  
Google, Microsoft, or plain SMTP and IMAP. Two-way, not just outbound.
* Calls on the record  
Built-in phone, with logs, recordings, and transcripts saved to the record too.
* Workflows in the inbox  
An incoming message can trigger a flow: auto-assign, auto-respond, auto-escalate.

[Read Inbox docs](https://flexie.io/resources/inbox/overview)

Automate

## Cut the hours your most complex processes eat.

Your business runs on processes too detailed to track by hand, the steps that have to fire when a deal closes, a renewal comes due, a ticket ages. Build each one once, the way it actually works, and Flexie runs it the moment it is needed, so the complicated parts of your business never wait on someone to remember.

* No developer, no waiting  
Describe the process in plain words and Flexie AI builds the whole flow, trigger, steps, and branches, ready to review and switch on.
* Nothing slips through  
The flow fires the instant a deal changes, a message lands, or a due date arrives, so the work happens whether or not anyone is watching.
* Your judgment, every time  
Flows branch on what matters, so your biggest accounts get the right treatment and nothing gets a one-size-fits-all response.
* Keeps up on your busiest day  
Thousands of records move through at once instead of one at a time, so an end-of-quarter rush never turns into a backlog.
* The whole process, not a piece  
One flow handles billing, messaging, your other tools, and AI in a single run, so no one is copy-pasting between systems.
* Change it without the fear  
Test a flow on a real record before it goes live, see what every step did, and undo any change in a single click.

[Read Workflows docs](https://flexie.io/resources/workflows/overview)

Build

## Your hardest requirement, no second system.

Sooner or later a requirement is too specific for any dropdown, and most teams buy a second system or wait months on a custom build. In Flexie your engineers write Flexie Scripting, stand up their own endpoints, expose virtual entities, and read or write every record over the REST API, while everyone else keeps working the simple screens.

* Logic no dropdown can hold  
When a rule is too specific to configure, write it directly in Flexie Scripting, no second tool required.
* Your own APIs, not a queue  
Stand up your own HTTP endpoints inside Flexie, with auth, CORS, and payloads already handled for you.
* Live answers, zero extra storage  
Virtual entities expose computed logic as records you query like a table, with no stored copy.
* Nothing locked behind a screen  
A full REST API reads and writes every record and runs every action, on standard auth.
* Your systems hear it first  
Webhooks push to your systems the moment anything changes, with automatic retries and logs.
* Connect on your own terms  
Run integrations on your own credentials and endpoints, never boxed into a vendor's list.

[Read Scripting docs](https://flexie.io/resources/flexie-scripting/overview)

Decide

## Live numbers, not last week's spreadsheet.

When your numbers live in exports and side spreadsheets, every meeting starts by arguing over which ones are right. Flexie builds your dashboards and reports on the live data your business already runs on, so the figure on the screen, in the report, and in the workflow is one number, current the moment you open it.

* Never last night's figures  
Every view recomputes from live data the moment it opens, so you decide on where the business is now, not last night's snapshot.
* One truth, not twelve copies  
The dashboard, the workflow, and the export all read from one saved definition, so teams stop arguing over whose spreadsheet is right.
* Every team sees what's theirs  
Sales opens the pipeline, support the case load, leadership the KPIs, each scoped to whoever signed in, all from one definition.
* Answer your own question on the spot  
Slice a report to this week or this quarter yourself, so one setup answers a dozen questions without waiting on an analyst.
* The number lands where the work happens  
Drop a report into a workflow and the right person just gets the figure they need, without going looking for it.
* When rows and columns won't do  
Build a custom page of tiles, charts, and boards for the messy questions a plain table can't answer, on the same live data.

[Read Reports docs](https://flexie.io/resources/reports/overview)

The architecture

## One source of truth, instead of a dozen that disagree.

In most companies the truth is scattered: one number in the CRM, another in a spreadsheet, a third in someone's inbox, and nobody sure which one is right. Flexie keeps a single copy of everything on one engine, so there is one version of each customer, each deal, each invoice, the same on every screen.

That is what turns the chaos into order. Change something once and every team sees it the same moment. A won deal, a paid invoice, a closed case each lands in one place and reaches everywhere it belongs, with nothing re-typed and nothing lost. The more you grow, the more that one source of truth keeps the whole company in step.

Real shapes

## What "shaped to your business" looks like.

Eight sketches of real Flexie implementations, not out-of-the-box templates. The same engine, shaped to eight different worlds.

Real estate

### A real-estate brokerage

Properties, landlords, and tenants as custom records. Viewing pipelines per property type. Contract workflows pulling dates from quotes and reminding agents. Dashboards by neighborhood, agent, and stage.

Custom recordsPipelinesWorkflowsDashboards

SaaS

### A subscription SaaS

Recurring plans with usage records. Dunning workflows escalating by channel and tone. Churn signals from inbox and phone activity. Customer-health dashboards on live data.

SubscriptionsDunningInboxHealth KPIs

B2B

### A B2B sales team

Multi-stage pipelines with stage-specific fields. Quotes flow to orders flow to invoices. Partner-portal forms creating leads. Forecast reports the founder reads on Monday.

PipelinesQuote to invoiceFormsForecasts

Field ops

### A service business

Cases with SLAs. Calendared follow-ups via SMS. Technician dispatch through workflows and the phone channel. An operations dashboard for active jobs.

CasesSLAsSMSPhone

Public sector

### A government agency

Citizen applications as custom records following statutory steps. Approval workflows branching by department to the right desk. Role-based access so each office sees only its part. A full audit trail on every decision.

Custom recordsApprovalsRole accessAudit trail

Software

### A software vendor

Licenses, seats, and add-ons as custom records. Order aggregation rolling many line items into one consolidated invoice. Mixed perpetual, subscription, and usage billing each cycle. Renewal reminders timed by workflow, revenue dashboards on live data.

Custom recordsOrder aggregationBilling cyclesRenewals

Vocational training

### A beauty academy

Web, ads, inbox, phone, and social leads as one stream. Applicants move through an admissions pipeline into student records. Student loans and financing tracked alongside. Native Stripe payment plans reconciled in Flexie finance.

Multi-channel leadsAdmissionsStudent loansStripe finance

Wellness

### A spa group

Clients call or text, Flexie AI answers and books on its own, no staff in the loop. Appointments land in the calendar as records. SMS confirmations and reminders that cut no-shows. Every call, text, and booking on one client timeline.

AI workforceCalls and SMSAuto bookingReminders

AI workforce

## Plug AI into any step. Or let it run the whole thing.

Flexie AI is not a chat box bolted on. It is an operator that uses the same engine you do. It acts under your supervision, asks for approval on anything material, and never locks you to one AI vendor.

[See what Flexie AI can do](https://flexie.io/ai)

Plain speak

## This is a deep platform, that's the point.

Picture software shaped to how you already work, with your real data and process modeled instead of squeezed into someone's template. One platform does the job of six glued-together tools, runs on simple everyday screens, and because we build it with you, it keeps fitting as you grow.

### Where Flexie pays off

* You run on custom data your business depends on daily, the kind no stock CRM was ever built to model.
* You live with exceptions, edge cases, and rules that keep changing, so a fixed template would break the first week.
* You want one platform doing the work that six separate tools do today, with nothing falling between the gaps.
* You want AI that acts on your data and takes the next step, not a chatbot that only ever suggests.
* You want the option to script and integrate on your own terms, without ever leaving the platform you run.
* You are ready to invest once in a setup shaped around how you actually work, instead of forcing a fit.

### Where it is not the right tool

* You just need a simple contact list and a few reminders, with no real process or logic sitting behind it.
* You want a free tier or a trial you can spin up tonight, with no one you have to talk to.
* Your data is small and your process already fits a stock template that works fine straight out of the box.
* You would rather set up a standard tool yourself this week and be done with it, with no help needed.
* Your needs are simple and rarely change, so software that bends to fit you is far more than you need.
* You want it live within days, with no time for the guided setup a platform this deep actually needs.

## Let's see if it fits your business.

Explore the live demo on your own, or book a call. We will learn how your business works, quote you a straight price, and give you an honest answer either way.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Pricing | Flexie: One All-In Platform, No Tiers, No Limits

Source: https://flexie.io/pricing

Pricing

# One platform. One offer.  
Nothing held back.

Flexie isn't sold in tiers. You get the entire platform, every module, for your whole team, with no per-user fees and no feature limits. We tailor a fair price to your business in a free consultation, and we'll tell you honestly if we're not the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

All-in, by default

## You get the whole platform, not a slice of it.

Most software hides the good parts behind a higher tier and charges you per seat. Flexie doesn't. One offer, everything switched on, for everyone on your team.

Every module included

* Sales & CRM
* Billing & Finance
* Calls & messaging inbox
* Support & Cases
* Automation
* Flexie AI workforce
* Custom records & fields
* Forms & dashboards
* Integrations & API

No limits, no surprises

* Your whole team, no per-user fees
* Unlimited workflows and automations
* No records, storage, or feature caps
* Your data, exportable anytime
* Free updates, for good
* Cloud or on your own servers
* Support from real people
* Vendor-independent AI, no lock-in
* No per-feature add-on charges

How pricing works

## Honest pricing starts with a conversation.

Your business isn't a template, so your price isn't one either. Flexie solves real, complex problems, so we set it up properly instead of dropping you into a sign-up form. Your quote is a one-time implementation tailored to your business, plus the platform, with no obligation at any step.

1

### Explore the live demo

Open a real Flexie workspace in your browser and click around. No signup, no credit card.

2

### Book a free consultation

A short, no-pressure call. We learn your business and what you need the platform to do.

3

### Get a straight price

A fair quote: a one-time implementation that sets you up properly, plus the platform. And an honest take on fit, even if that points you elsewhere.

The real comparison

## It replaces your whole stack, not just your CRM.

Most businesses cobble together a dozen tools that barely talk to each other, a separate bill and login for each, plus the hours lost keeping them in sync. Flexie does all of it in one place, so you usually pay less for far more, without the enterprise price tag of Salesforce or HubSpot.

What you'd otherwise buy separately

CRM & contactsSales pipelineQuotes & proposalsInvoicingRecurring billingEmail marketingSMS & WhatsAppCalls & telephonyShared inboxHelp desk & casesTask automationCustom databasesOnline formsDashboards & reportsIntegrations & APIAI workforceand more

A dozen subscriptions, a dozen logins, and the busywork of keeping them all in sync.

One Flexie

All of it in one platform. One login, one system, everything in sync.

Need it inside your own perimeter? Flexie runs [on-premises](https://flexie.io/on-premises) too, the same platform, on your own servers.

Straight answers

## Questions, answered honestly.

### Why isn't there a price on this page?

Because a fair price depends on your business, your size, and what you need Flexie to do. We'd rather give you a straight quote after a short conversation than post a sticker price that's wrong for most people.

### Do I set it up myself, or do you help?

We set it up with you. Flexie solves complex problems, so a standard implementation, tailored to your business, is part of getting started and billed once. After that, you can adjust it day to day yourself with point-and-click screens.

### What does the one-time implementation include?

Setting Flexie up around how your business actually runs: your modules, pipelines, fields, and workflows configured to fit, plus moving your existing data in. We scope it with you and quote it up front, so the figure is clear before you commit, and it's billed once rather than every month.

### Is there a free trial?

There's something better: a real, live demo workspace you can open right now, with no signup and no credit card. Explore the full product before you ever talk to us.

### Do you charge per user?

No. Your whole team is included. There are no per-seat fees and no counting heads as you grow.

### Are any features locked to a higher tier?

No. There is one offer, and it includes everything: every module, the AI workforce, automation, integrations, all of it. You are either all-in, or another tool is the better fit.

### What if Flexie isn't right for me?

We'll tell you. If another solution fits your needs better, we'll point you toward it. We would rather be honest than close a bad fit.

### Can I run it on my own servers?

Yes. Flexie runs in the cloud or on-premises inside your own infrastructure, the same platform either way.

## See it first, then let's talk price.

Explore the live demo on your own, or book a free consultation. We'll learn your business, give you a straight price, and tell you honestly whether Flexie is the right fit.

[Book a free consultation](https://flexie.io/contact)[Explore the live demo](https://flexie.io/explore-now)

No signup for the demo. No pressure on the call.

---

## Privacy Policy

Source: https://flexie.io/privacy-policy

Legal

# Privacy Policy

Effective date: 10 May 2026

## 1\. Scope

The controller for this Privacy Policy is Flexie CRM e.U., operated by Eriol Gjergji, Fritz-Konzert-Strasse 7, Top 1/3, 6020 Innsbruck, Austria, UID/VAT: ATU81616707, Firmenbuchnummer: FN 679939 k, Firmenbuchgericht: Landesgericht Innsbruck ("Flexie").

This Privacy Policy explains how Flexie processes personal data when Flexie acts as controller under the General Data Protection Regulation (GDPR) and the Austrian Data Protection Act (Datenschutzgesetz, DSG). It covers data collected through the flexie.io website, account creation, billing and payment administration, identity verification (KYC), support communications, security operations, marketing communications, and business correspondence.

## 2\. What This Policy Does Not Cover

This Privacy Policy does **not** apply to personal data that a Flexie customer stores or processes inside its own Flexie CRM deployment. When a customer uses Flexie CRM to manage data about its own leads, contacts, employees, end users, or other persons, the customer is the controller for that data and Flexie acts as processor on the customer's documented instructions. That processing is governed by the Flexie [Data Processing Agreement (PDF)](https://flexie.io/documents/flexie-dpa-de-en-ai-act.pdf), not this Policy.

If you are a data subject whose personal data is stored or processed inside a Flexie customer's deployment (for example, you are a contact, lead, employee, or end user of a business that uses Flexie CRM), please contact that business directly to exercise your rights. Flexie cannot act on requests relating to a customer's controller data without the customer's instruction or a binding legal obligation to do so.

## 3\. Contact

For privacy questions about Flexie's own controller processing, contact: [support@flexie.io](mailto:support@flexie.io). Data protection matters are handled internally by the management of Flexie CRM e.U.

## 4\. No Data Protection Officer (DPO)

Flexie has not appointed a designated Data Protection Officer (Datenschutzbeauftragter, DPO). This Section sets out the legal reasons why a DPO appointment is not required for Flexie under applicable law.

Article 37(1) GDPR makes the appointment of a DPO mandatory only in the three cases listed below. Flexie does not meet any of them:

1. **Public authority or body (Article 37(1)(a) GDPR).** Flexie CRM e.U. is a privately owned, registered sole proprietorship (Unternehmer within the meaning of § 1 UGB), entered in the Austrian commercial register (Firmenbuchnummer FN 679939 k), and is not a public authority or public body.
2. **Regular and systematic monitoring of data subjects on a large scale (Article 37(1)(b) GDPR).** Flexie's core activity is the provision of a business-to-business CRM and workflow automation platform to registered businesses (see Section 2 of the Terms of Service). Flexie does not conduct behavioral profiling, online tracking, location monitoring, large-scale advertising targeting, or other regular and systematic monitoring of data subjects as a core activity. The processing of account, billing, and KYC data described in Section 5 of this Policy concerns Flexie's business customers and their authorized representatives, in volumes typical of a small business, and is not large-scale monitoring of data subjects.
3. **Large-scale processing of special-category or criminal-conviction data (Article 37(1)(c) GDPR).** Flexie does not, as part of its core activities, process special categories of personal data within the meaning of Article 9 GDPR (such as data on racial or ethnic origin, political opinions, religious or philosophical beliefs, trade-union membership, genetic data, biometric data for unique identification, health data, sex life, or sexual orientation), or personal data relating to criminal convictions and offences within the meaning of Article 10 GDPR. Flexie does not target, market to, or specifically support customers in healthcare, banking, insurance, financial services, or other regulated sectors whose ordinary business operations require the large-scale processing of special-category or criminal-conviction data. The Service is offered as a general business CRM and workflow platform for ordinary commercial customers. Where a customer nonetheless chooses to process such data inside its own Flexie CRM deployment, that customer is the controller for that processing and is responsible for assessing whether the customer's own DPO obligation is triggered (see Section 2 of this Policy).

For the avoidance of doubt regarding Flexie's role as processor: when Flexie processes personal data on behalf of a customer inside that customer's Flexie CRM deployment, Flexie's role is to host the software and the data, not to monitor, profile, or otherwise determine the purposes of that processing. The volume of personal data that a customer chooses to process inside its own deployment does not, by itself, convert Flexie's processor activity into "regular and systematic monitoring of data subjects on a large scale" within the meaning of Article 37(1)(b) GDPR, and does not by itself convert Flexie's processor activity into "large-scale processing of special categories of personal data" within the meaning of Article 37(1)(c) GDPR. Each customer remains responsible for assessing whether its own processing triggers a DPO appointment obligation for that customer under Article 37 GDPR.

§ 5 of the Austrian Data Protection Act (Datenschutzgesetz, DSG) reproduces and complements Article 37 GDPR for Austrian public bodies and does not extend the mandatory-appointment criteria beyond Article 37 GDPR for private controllers such as Flexie.

This assessment is consistent with the Article 29 Working Party Guidelines on Data Protection Officers (WP 243 rev. 01, endorsed by the European Data Protection Board) and with the published practice of the Austrian Data Protection Authority (Datenschutzbehörde).

Independently of the GDPR threshold above, an appointment by the sole proprietor of Flexie CRM e.U. as DPO would not be permissible: under Article 38(3) and (6) GDPR, a DPO must act independently, must not receive instructions regarding the performance of DPO tasks, and must not hold a role that decides the purposes and means of processing. The sole proprietor is the controller and decides those purposes and means, which creates a structural conflict of interest expressly identified in WP 243.

Even though Flexie is not required to appoint a DPO, Flexie maintains the following measures for data protection governance:

* a single privacy contact, [support@flexie.io](mailto:support@flexie.io), for all data subject requests, complaints, and supervisory authority correspondence;
* an internal Verzeichnis von Verarbeitungstätigkeiten (Records of Processing Activities) under Article 30 GDPR;
* documented data protection policies, including this Privacy Policy, the Cookie Policy, the Data Retention Policy, and the Data Processing Agreement applicable to processor processing;
* incident-response procedures for personal data breaches, including the supervisory authority notification timeline required by Article 33 GDPR.

Flexie will reassess this position if and when its processing activities materially change. If appointment becomes mandatory, or if Flexie elects to appoint a DPO voluntarily, this Policy will be updated to identify the DPO and the relevant contact details.

## 5\. Personal Data We Process as Controller

As controller, Flexie processes the following categories of personal data in connection with the website, account administration, billing, identity verification, support, security, and marketing communications. This list does not cover personal data that customers process inside their own Flexie CRM deployments, which is governed by the Data Processing Agreement (see Section 2).

* Account and business contact data: name, company, email, phone, role, account identifiers.
* Billing and payment administration data: invoices, billing address, VAT number, payment status, payment-channel identifiers (for example PayPro Global or Stripe references), bank transfer details, and related records.
* Identity verification and Know Your Customer (KYC) data: company registration extract details, legal-entity identifiers, authorized representative and beneficial ownership information, identity documents supplied for verification, sanctions and anti-money-laundering / counter-terrorism financing check results, and related records. The Service is offered to businesses only and is not sold to consumers; KYC checks apply to business customers and their representatives.
* Support and communication data: emails, support messages, call notes, issue details, attachments supplied to support, and related metadata.
* Website and usage data: IP address, browser, device data, pages visited, cookie identifiers, referral data, timestamps, and log information.
* Security data: authentication events, access logs, abuse-prevention records, audit logs, and incident records.
* Marketing communication data where you subscribe to or request communications from Flexie, including opt-in records and unsubscribe history.

## 6\. Special-Category Data

Flexie does not invite, request, or intentionally process special categories of personal data within the meaning of Article 9 GDPR (data revealing racial or ethnic origin, political opinions, religious or philosophical beliefs, trade-union membership, genetic data, biometric data for unique identification, data concerning health, or data concerning sex life or sexual orientation), or personal data relating to criminal convictions and offences within the meaning of Article 10 GDPR, through the controller channels covered by this Policy.

You should not submit special-category or criminal-conviction data to Flexie through the website, contact forms, support communications, or account registration. If such data is nonetheless received, Flexie will delete it as soon as reasonably practicable unless a legal obligation requires retention.

Where a customer chooses to process special-category or criminal-conviction data inside its own Flexie CRM deployment, that processing is governed by the Data Processing Agreement and is the customer's responsibility as controller (see Section 2).

## 7\. Sources of Personal Data

Flexie collects personal data primarily from you directly when you visit the website, create an account, contact support, sign a contract, or correspond with Flexie. Flexie may also receive personal data from:

* public registers and lists used for KYC, including commercial register extracts, beneficial ownership registers, sanctions and politically-exposed-person lists, and equivalent sources;
* payment processors and infrastructure providers, where they share data necessary to provide their service, such as payment status or fraud signals;
* your colleagues or your organization, where someone else on your team creates the account or invites you as a user;
* publicly available business sources, where Flexie reasonably uses such information for business-to-business outreach permitted under applicable Austrian and EU law.

## 8\. Purposes and Legal Bases

| Purpose                                                                                                        | Legal basis                                                                                                                                                                                                                            |
| -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Accounts, administration, billing, support, and customer communication                                         | Contract performance or pre-contractual steps (Art. 6(1)(b) GDPR)                                                                                                                                                                      |
| Service security, abuse prevention, logging, troubleshooting                                                   | Legitimate interests under Art. 6(1)(f) GDPR (protecting the Service, Flexie's customers, and third parties from fraud, abuse, unauthorized access, and operational failures), and legal obligations where applicable.                 |
| Accounting, tax, statutory recordkeeping                                                                       | Legal obligation (Art. 6(1)(c) GDPR)                                                                                                                                                                                                   |
| Customer identity verification, KYC, anti-money-laundering and sanctions screening, fraud and abuse prevention | Legal obligation and legitimate interests under Art. 6(1)(c) and (f) GDPR, including complying with AML/CTF, sanctions, and tax obligations, preventing financial crime, and protecting Flexie from contractual and reputational risk. |
| Service notices and product communications to existing customers                                               | Contract performance or legitimate interests under Art. 6(1)(b) or (f) GDPR, namely keeping customers informed about the Service they use and changes relevant to them.                                                                |
| Marketing communications                                                                                       | Consent (Art. 6(1)(a) GDPR; § 174 TKG 2021; § 7 ECG) or, where legally permitted, legitimate interests in B2B prospecting, with an unsubscribe option in every electronic marketing message.                                           |
| Non-essential cookies and analytics                                                                            | Consent (Art. 6(1)(a) GDPR; § 165 TKG 2021)                                                                                                                                                                                            |

## 9\. Whether Provision of Personal Data Is Required

Provision of account, billing, and KYC data is required to enter into and perform the contract with Flexie. If you do not provide that data, Flexie cannot open an account, issue invoices, process payments, complete KYC, or provide the Service. Provision of marketing preferences and optional support details is voluntary; refusal does not affect Flexie's ability to provide the Service.

## 10\. Automated Decision-Making and Profiling

Flexie does not use automated decision-making that produces legal effects or similarly significantly affects you within the meaning of Article 22 GDPR for the controller processing covered by this Policy. Automated checks within KYC, such as comparing inputs against sanctions and PEP lists, inform human review and are not by themselves used as the sole basis for a decision with legal effect.

If a customer configures automated decision-making or profiling inside its own Flexie CRM deployment, that processing is the customer's responsibility as controller and is not governed by this Policy.

## 11\. Marketing Communications

Flexie sends electronic marketing communications, such as email newsletters or product announcements, only with prior consent where consent is required under § 174 TKG 2021 and § 7 ECG, or where the recipient is an existing business customer receiving information about similar products or services as permitted by Austrian law. You can withdraw consent or opt out of marketing at any time by using the unsubscribe link in any marketing email or by contacting [support@flexie.io](mailto:support@flexie.io). Withdrawal does not affect the lawfulness of processing carried out before withdrawal.

Marketing emails may include open and click tracking technologies, such as tracking pixels and tracked links, that record whether you opened a message and which links you followed, together with related technical metadata. Flexie uses this information to measure campaign performance, improve content relevance, and segment future communications. You can disable image loading in your email client to limit open tracking. Unsubscribing from marketing communications ends both the messages and the associated tracking.

## 12\. Children

The Service is offered to businesses only and is not directed at children. Flexie does not knowingly collect personal data from persons under the age of 14, which is the Austrian digital consent threshold under § 4 (4) DSG. If you believe a child has provided personal data to Flexie, contact [support@flexie.io](mailto:support@flexie.io) and the data will be deleted.

## 13\. Customer-Configured Integrations

Customers may configure integrations with external systems such as email, SMS, telephony, webhooks, APIs, databases, payment systems, analytics endpoints, or AI/API services. These are selected and controlled by the customer. Where Customer configures such an integration, Flexie processes or transmits data according to Customer's configuration and instructions.

Customer-selected integration providers are not Flexie sub-processors merely because the Service provides integration tooling. Customers are responsible for assessing those providers, entering into required contracts, configuring payloads, and complying with legal requirements.

## 14\. AI and Automation

Flexie does not train, fine-tune, own, operate, or run general-purpose AI models or third-party AI models for Customer's use of the Service unless separately agreed in writing. Where Customer configures AI/API endpoints or AI-related workflows, Customer controls the provider, endpoint, prompts, payloads, fields, and output use.

Within the meaning of Regulation (EU) 2024/1689 (EU AI Act), Flexie is not a provider, a deployer, or a general-purpose AI model provider in respect of Customer's use of the Service. Customer is the deployer of any AI system that Customer configures through the Service and is responsible for the deployer obligations under Articles 4 and 26 of the EU AI Act, the transparency obligations under Article 50 where applicable, and the prohibitions in Article 5\. The Terms of Service include Customer's substantive obligations in this area; this Policy describes the related personal-data implications.

Flexie provides field-level permission and exclusion tools where available so Customers can exclude fields such as phone numbers, email addresses, identifiers, sensitive notes, or other selected data from AI-related workflows or payloads. Customer is responsible for configuring and maintaining those controls.

Flexie does not, as controller, use AI to process personal data in a manner that produces legal effects or similarly significantly affects data subjects within the meaning of Article 22 GDPR. See also Section 10 (Automated Decision-Making and Profiling).

## 15\. Recipients and Sub-Processors

Flexie may share personal data with the following categories of recipients, only as necessary for the purposes set out in this Policy:

* Infrastructure providers for hosting, compute, storage, networking, and backups. Current authorized providers are OVH SAS, Hetzner Online GmbH, and Amazon Web Services EMEA SARL, using European data centers / EU/EEA regions for core hosting unless otherwise agreed or configured by Customer.
* Payment processors (PayPro Global and Stripe) for processing payments and managing related billing data, and banks for SEPA and equivalent transfers.
* KYC and compliance data sources, including providers of commercial register data, sanctions screening, and PEP screening, as needed to perform required checks.
* Professional advisers such as accountants, auditors, tax advisers, and lawyers, where required for legal, accounting, or tax reasons.
* Authorities and courts, where required by law, court order, or to establish, exercise, or defend legal claims.
* Successors in the context of a corporate transaction such as merger, acquisition, or asset sale, subject to confidentiality and applicable law.

Sub-processors that process Customer Personal Data on Flexie's behalf for the Service are governed by the Data Processing Agreement, which sets out the sub-processor regime and notice mechanism for personal data.

## 16\. International Transfers

Flexie aims to process core Customer Personal Data within the EU/EEA for the Service. If a transfer outside the EU/EEA is required for Flexie-controlled processing, Flexie will use a valid transfer mechanism where required, such as the European Commission's Standard Contractual Clauses (Implementing Decision (EU) 2021/914) and, where applicable, additional supplementary measures. If Customer configures an integration to an external or non-EEA endpoint, that transfer is made on Customer's instruction and Customer is responsible for assessing and implementing the required transfer mechanism.

## 17\. Retention

Personal data is retained only for as long as necessary for the purposes described in this Policy, the Data Retention Policy, the applicable agreement, legal obligations, dispute resolution, security, and legitimate business needs. KYC and accounting records are retained for the periods required by Austrian AML/CTF and tax law. See [Data Retention Policy](https://flexie.io/data-retention-policy).

## 18\. Your Rights

Where applicable, you have rights under the GDPR and the DSG to:

* access your personal data (Art. 15 GDPR);
* request rectification of inaccurate data (Art. 16 GDPR);
* request erasure (Art. 17 GDPR);
* request restriction of processing (Art. 18 GDPR);
* object to processing based on legitimate interests, including direct marketing (Art. 21 GDPR);
* data portability for data processed by automated means under contract or consent (Art. 20 GDPR);
* withdraw consent where processing is based on consent (Art. 7(3) GDPR);
* lodge a complaint with a supervisory authority (Art. 77 GDPR).

Requests relating to Flexie's own controller processing may be sent to [support@flexie.io](mailto:support@flexie.io). Requests relating to Customer CRM data should be sent to the relevant Flexie customer acting as controller; see Section 2.

## 19\. Supervisory Authority

You may contact the Austrian Data Protection Authority (Datenschutzbehörde), Barichgasse 40-42, 1030 Vienna, Austria, or another competent supervisory authority in your Member State, if you believe your rights have been infringed.

## 20\. Security

Flexie applies reasonable technical and organizational security measures to protect personal data, as further described on the [Security & Infrastructure](https://flexie.io/security-infrastructure) page. No system is completely secure; Customers remain responsible for account security, user permissions, integration credentials, workflow configuration, and field-level controls.

## 21\. Personal Data Breaches

Flexie maintains documented procedures for identifying, assessing, containing, and reporting personal data breaches in accordance with Articles 33 and 34 GDPR.

Where a personal data breach for which Flexie acts as controller occurs, Flexie will notify the Austrian Data Protection Authority (Datenschutzbehörde) without undue delay and, where feasible, not later than 72 hours after becoming aware of the breach, in accordance with Article 33 GDPR, unless the breach is unlikely to result in a risk to the rights and freedoms of natural persons. Where a breach is likely to result in a high risk to those rights and freedoms, Flexie will also communicate the breach to the affected data subjects without undue delay, in accordance with Article 34 GDPR.

Where a breach occurs in respect of Customer Personal Data for which Flexie acts as processor on behalf of a customer, Flexie will notify the customer in accordance with the Data Processing Agreement so that the customer can fulfil its own Article 33 and 34 GDPR obligations as controller.

Internal breach handling, including investigation, root-cause analysis, mitigation, and record keeping under Article 33(5) GDPR, follows Flexie's incident-response procedures.

## 22\. Cookies and Web Analytics

The Flexie website uses **no cookies** and stores nothing on your device for tracking; see the [Cookie Policy](https://flexie.io/cookie-policy). For aggregate website statistics we use **Umami** (Umami Cloud, umami.is) as our analytics processor. Umami is **cookieless**: it stores no cookies or identifiers on your device and does not identify you. It processes only anonymous, aggregated usage data, namely pages viewed, the referring website, approximate country (derived from your IP address, which is not stored), and browser or device type. It does not build a personal profile and does not track you across other websites. Legal basis: our legitimate interest in understanding and improving the website (Art. 6(1)(f) GDPR). Where Umami processes data outside the EEA, appropriate safeguards apply. We do not use it for advertising. Cookies in the separate Flexie CRM application are addressed in the [Cookie Policy](https://flexie.io/cookie-policy).

## 23\. Changes

Flexie may update this Privacy Policy from time to time. The updated version will be published on the website with a new effective date. Where changes materially affect how Flexie processes your personal data, Flexie will notify you by reasonable means in advance of the effective date.

---

## Resources & Knowledge Base

Source: https://flexie.io/resources

Resources

# Knowledge base.

Guides and how-tos for running your business on Flexie, from first import to advanced automation.

## Getting Started

[Getting StartedYour first day with Flexie. Set up your account, invite your team, bring in your customers, connect your channels, and find your way around.](https://flexie.io/resources/getting-started/introduction)

## CRM & Customers

[Contacts & LeadsHow Flexie handles the people and companies you do business with. Capture leads, organise contacts and companies, and keep every customer's full history on one timeline.](https://flexie.io/resources/crm/contacts-and-leads)[Deals & PipelinesHow Flexie tracks sales opportunities from first interest to closed deal on a visual pipeline, and flows won deals straight into quotes and invoices.](https://flexie.io/resources/crm/deals-and-pipelines)[Cases & SupportHow Flexie helps you handle customer questions and problems without losing track, turning messages into trackable cases with an owner, a status, and a clear finish line.](https://flexie.io/resources/crm/cases-and-support)

## Finance

[OverviewThe full Finance area at a glance. A deal becomes a quote, the quote converts to one or more invoices, invoices collect payments, and the books keep themselves balanced underneath.](https://flexie.io/resources/finance/overview)[QuotesA price offer to your customer, before any money changes hands. Build it from products, send it as a PDF, and when the customer agrees, turn it into an invoice.](https://flexie.io/resources/finance/quotes)[Convert to CashThe smart bridge from a quote to one or more invoices. Down payments, percentage and fixed-amount billing, and a guarantee that you never invoice more than 100% of the quote total.](https://flexie.io/resources/finance/convert-to-cash)[InvoicesThe bill you send a customer. Created on its own or, more often, from a quote. An invoice is the moment a sale becomes real revenue in your books.](https://flexie.io/resources/finance/invoices)[PaymentsRecording the money that comes in against your invoices. Partial or full, multiple payments per invoice, with the payment status updating itself as you go.](https://flexie.io/resources/finance/payments)[AccountingBehind every invoice and every payment, Flexie writes the bookkeeping for you. Chart of accounts, double-entry journal entries, balance sheet, all kept in step with what you've billed and what you've collected.](https://flexie.io/resources/finance/accounting)[ProductsEverything you sell. Physical products with stock, services billed by the hour, day, or job. Products are the building blocks every quote and every invoice is made of.](https://flexie.io/resources/finance/products)[TaxesDefine each tax rate once, attach it to the products it applies to, and Flexie does the maths everywhere, quotes, invoices, accounting.](https://flexie.io/resources/finance/taxes)

## Inbox

[OverviewThe shared inbox concept, how to switch between channels, the filter pill, how messages auto-link to customer records, and how conversations are grouped across email, SMS, and WhatsApp.](https://flexie.io/resources/inbox/overview)[Email ChannelConnecting a mailbox (Google, Microsoft, Other), composing replies and forwards, how incoming email is handled and threaded, the two email workflow triggers (Incoming emails and Email opened) plus the Save email attachments to the customer action.](https://flexie.io/resources/inbox/email)[SMS ChannelConnecting a text-messaging line, sending SMS from anywhere in Flexie, what happens when an SMS comes in, and the two SMS workflow triggers (Incoming SMS and SMS delivered) plus the Send SMS workflow action.](https://flexie.io/resources/inbox/sms)[WhatsApp ChannelPairing a WhatsApp number, sending text and media to direct chats and groups, how customers' messages reach your inbox, and the Incoming WhatsApp workflow trigger plus the Send WhatsApp action.](https://flexie.io/resources/inbox/whatsapp)[Templates (Email & SMS)Saved messages with variables you drop into compose with one click. Email templates and SMS templates are separate libraries; the SMS library also feeds the WhatsApp compose form.](https://flexie.io/resources/inbox/templates)[Inbox in WorkflowsThe consolidated catalogue. Every channel trigger and action with what each one runs against, the data each one makes available to your workflow, five end-to-end recipes that bridge email, SMS, and WhatsApp, and a debug checklist for when a trigger doesn't run.](https://flexie.io/resources/inbox/workflows-and-automation)

## Telephony

[OverviewFlexie has a phone built into the platform. Click a customer's number, your browser rings, you talk, all without leaving the page. Covers the softphone, call logs, live supervision, and call workflow triggers.](https://flexie.io/resources/phone/overview)[ChannelsPicking a phone channel, the configuration screens for Twilio and a self-hosted PBX, how phone numbers and per-user extensions are wired up, and access control on both.](https://flexie.io/resources/phone/channels)[The SoftphoneThe in-browser dialer docked at the bottom of every Flexie page. Where calls ring, where you click to dial, and where in-call controls live.](https://flexie.io/resources/phone/softphone)[Call Logs & TimelineWhere every call goes after it ends. What the call record holds, how it links to customers, where to find recordings, and how calls show up on the customer's timeline.](https://flexie.io/resources/phone/call-logs-and-timeline)[Live MonitorA supervisor-only screen that shows every call happening right now, who's on it, and lets you listen in, whisper to your agent, or barge into the call. The classic call-centre supervision triad.](https://flexie.io/resources/phone/live-monitor)[WorkflowsWhen a call ends, an automation can pick up. Log a follow-up task, send a thank-you SMS, change a deal stage, fire any other workflow action. Covers the Completed call trigger and the Match past calls action.](https://flexie.io/resources/phone/workflows-and-automation)

## Flexie AI

[OverviewFlexie's AI is built into the platform and does the work, not just chat. The four building blocks, the four ways to put it to work, and the rule that keeps it safe, acting only within your permissions and asking before anything important.](https://flexie.io/resources/ai/overview)[The chat assistantThe most direct way to use Flexie's AI. Type what you need the way you would tell a capable colleague, watch it work, build on your last message, and approve before anything is sent.](https://flexie.io/resources/ai/chat-assistant)[What the assistant can doThe assistant's abilities in plain language, from finding and understanding your data to taking action, building automations, managing your setup, and reaching beyond Flexie. Every ability can be switched off or set to ask first.](https://flexie.io/resources/ai/what-it-can-do)[Approvals & safetyFlexie's AI is careful by design. It asks before anything that changes your data, it stays inside the permissions of the person using it, and you control who is allowed to use it at all.](https://flexie.io/resources/ai/approvals-and-safety)[Knowledge bases (Brains)A knowledge base, called a Brain in Flexie, is your own curated library of facts the assistant can search, read, and ground its answers in. How to build one, lock it, and assign it to an assistant.](https://flexie.io/resources/ai/knowledge-bases)[SpecialistsWhen a request needs deep, focused work, the assistant hands it to a specialist built for that task and brings the result back. You only ever talk to one assistant. How specialists work and what you configure.](https://flexie.io/resources/ai/specialists)[AI in workflowsPlace an AI step inside an automated process and it does its job unattended, the same way every time, for the whole business. How the AI Agent step works, what you set, and what people build with it.](https://flexie.io/resources/ai/ai-in-workflows)[AI by text & WhatsAppPut the AI to work from the messaging app on your phone. Text or WhatsApp the assistant for live numbers or to get a job done, no app and no login, with the same safety rules as everywhere.](https://flexie.io/resources/ai/by-text-and-whatsapp)[Settings & modelsEverything that shapes the assistant in one place. Connect a provider, pick the model, add specialists, switch abilities on or off, set what needs approval, assign knowledge bases, and choose who can use it.](https://flexie.io/resources/ai/settings-and-models)[Connecting outside assistantsIf your team already works in an AI assistant elsewhere, Flexie can safely open its abilities to it through an open standard, so it can look up records, run reports, and trigger automations without anyone leaving the tool they are in.](https://flexie.io/resources/ai/connect-outside-assistants)[Activity & oversightEverything the AI does is recorded. See what was asked, what it did, when, who ran it, and what it cost, so the assistant is accountable rather than a black box.](https://flexie.io/resources/ai/activity-and-oversight)

## Forms

[OverviewA Form is a structured way of collecting information, from people outside Flexie or from your own team inside it. Someone fills it, Flexie stores the submission, a workflow can react instantly.](https://flexie.io/resources/forms/overview)[Creating a FormFrom an empty builder to a saved configured form. The three first choices you can't change later, the drag-and-drop canvas, every field type, per-field settings, validation, and the form-level settings.](https://flexie.io/resources/forms/creating-a-form)[Public (External) FormsPublic-facing forms anyone can fill in without logging into Flexie. Their URL, the embed snippet for your website, reCAPTCHA, analytics, file uploads, GDPR, and signed-URL private forms.](https://flexie.io/resources/forms/public-forms)[Internal FormsForms used by your own team inside Flexie. Entity-bound forms attached to a record's profile, virtual forms in the top-nav or dialer, prefill from the record, placement, access control, and the listener side-by-side.](https://flexie.io/resources/forms/internal-forms)[SubmissionsEvery form submission is stored. Where they live, how to view them, how to read their contents safely in Flexie Scripting, and the bracket-notation rule for keys with spaces.](https://flexie.io/resources/forms/submissions)[Forms in WorkflowsThe reference page for everything that connects a form to an automation. The three listeners with their exact \_\_data shapes, the two form-related workflow actions, and the request/response polling pattern.](https://flexie.io/resources/forms/forms-in-workflows)

## Reports

[OverviewA report is a saved query plus a presentation. It turns your live data into operational lists, KPIs, custom dashboards-in-a-page, and a feed other parts of Flexie can read.](https://flexie.io/resources/reports/overview)[Data Grid ReportsA query-driven report that presents its result as a sortable, filterable, exportable table. The default and most common kind, backed by a SELECT statement.](https://flexie.io/resources/reports/data-grid-reports)[HTML ReportsA report whose body is HTML, CSS, and JavaScript with Flexie Scripting. The escape hatch from the data grid for building anything you can build on a web page, driven by live data.](https://flexie.io/resources/reports/html-reports)[Viewing, Exporting & AccessWhat the report view page does, how CSV exports work, and how the two-layer access model (role permissions plus the per-report "Who can access this report?" list) decides who can see what.](https://flexie.io/resources/reports/viewing-exporting-sharing)[Reports in Workflows & DashboardsA saved report is more than a page. It is a reusable data source for dashboards, for HTML reports, for workflow steps, and via the API for outside systems.](https://flexie.io/resources/reports/reports-in-workflows-and-widgets)[Report Filters (in depth)User-input filters above a report. The JSON that defines them, the controls they render, the three ways their values reach your query, and how Flexie Scripting can drive the filter definition itself.](https://flexie.io/resources/reports/filters)

## Dashboards

[OverviewA dashboard is a page made of widgets, each a self-contained visualisation. Build screens of live charts and figures from built-in widgets, saved reports, and fully custom HTML.](https://flexie.io/resources/dashboards/overview)[Built-In WidgetsThe complete catalogue of widgets Flexie ships out of the box. Each one is backed by a specific feature inside the product, so it always has live data ready to drop on a dashboard.](https://flexie.io/resources/dashboards/built-in-widgets)[Report WidgetsTurn a saved Data Grid report into a dashboard widget. One query, six visualisations, any number of widgets. Edit the report and every widget that uses it picks up the change.](https://flexie.io/resources/dashboards/report-widgets)[Custom HTML WidgetsDrop an HTML report onto a dashboard and the rendered template becomes the widget. With the full Flexie Scripting toolkit and any JavaScript library, you can build any widget you can imagine.](https://flexie.io/resources/dashboards/custom-html-widgets)[Layout & SharingSizing widgets, ordering them on the page, the cache that keeps the dashboard fast, multiple dashboards, who can see what, and how to publish a dashboard publicly behind a signed link.](https://flexie.io/resources/dashboards/layout-and-sharing)

## Workflows

[OverviewThe complete guide to Flexie's automation engine. How workflows are built, how they run, and how to make them do real work reliably.](https://flexie.io/resources/workflows/overview)[Building a WorkflowStep by step, from an empty canvas to a live automation. The basics, the canvas, how steps connect into a tree, configuration, testing, and the publishing lifecycle.](https://flexie.io/resources/workflows/building-a-workflow)[Triggers & SourcesEvery workflow needs a starting condition, its source. There are five sources, and choosing the right one is the single most important decision in a workflow.](https://flexie.io/resources/workflows/triggers-and-sources)[Actions & DecisionsActions do things. Decisions choose paths. Together they are the body of every workflow. The full catalogue, the operators, the time conditions, the listeners, and the rules.](https://flexie.io/resources/workflows/actions-and-decisions)[Runtime, Parallel Execution & the TreeWhat actually happens when a workflow runs. The tree, immediate vs background running, parallel branches, step timing, and how a decision splits a batch of records.](https://flexie.io/resources/workflows/runtime-parallel-and-tree)[Passing Data Between StepsHow a step uses what the trigger and earlier steps produced. The \_\_data namespace, the workflow's shared notepad, plus how listeners, the webhook action, the AI step, and Store a value all write into it.](https://flexie.io/resources/workflows/passing-data-between-steps)[Scheduling, Testing & TroubleshootingTiming controls, the test run, the activity logs, version history, and the mistakes people make most often. The page you keep open while you build, run, and debug a workflow.](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting)

## Flexie Scripting

[OverviewThe small, safe language built into Flexie that turns stored data into finished text, numbers, links, and decisions, anywhere you see a script field.](https://flexie.io/resources/flexie-scripting/overview)[Language BasicsEverything you need to read and write Flexie Scripting confidently. Values, record fields, conditions, loops, operators, tests, comments, and the always-available globals.](https://flexie.io/resources/flexie-scripting/language-basics)[Function ReferenceThe complete toolbox. Every built-in function, grouped by what it does, with the arguments it takes and an example you can adapt.](https://flexie.io/resources/flexie-scripting/function-reference)[Filters & Working with ListsFilters reshape a single value. Collection helpers work across a whole list of records. Together they cover most "format this" and "summarise these" jobs.](https://flexie.io/resources/flexie-scripting/filters-and-collections)[RecipesComplete, ready-to-adapt examples for the things people actually build. Every recipe uses only documented functions and notes where you would use it.](https://flexie.io/resources/flexie-scripting/recipes)[Where It Runs & Its LimitsWhich data a script can see depends on where it runs, and what it can do is bounded by a safety sandbox. This page sets both expectations clearly.](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits)

## Dynamic Endpoints

[OverviewA dynamic endpoint is a private web address that an outside system can send data to, which instantly runs a workflow. It is how Flexie receives data from anywhere and acts on it.](https://flexie.io/resources/dynamic-endpoints/overview)[Virtual EntitiesThe "record" a workflow runs on when there is no stored row, when the data is the thing that just arrived. The special record type that powers dynamic endpoints and other inbound-signal workflows.](https://flexie.io/resources/dynamic-endpoints/virtual-entities)[Creating an EndpointMaking the workflow, getting your unique URL, and locking it down with JWT authentication and cross-origin rules.](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint)[Receiving DataExactly where the incoming request lands, so your steps can use it. Get this right and everything else follows; get it wrong and tokens come back empty.](https://flexie.io/resources/dynamic-endpoints/receiving-data)[Virtual ConditionsThe decision type that branches on data which is not a stored field, the values that arrived with the request or that earlier steps produced.](https://flexie.io/resources/dynamic-endpoints/virtual-conditions)[Responding to the CallerAn endpoint can reply to whatever called it. There are five ways, from a fixed "thanks, received" to a live streamed response computed by the workflow.](https://flexie.io/resources/dynamic-endpoints/responding)[End-to-End ExamplesComplete round trips you can adapt. Each shows the incoming request, the workflow steps, the tokens used, and the response.](https://flexie.io/resources/dynamic-endpoints/examples)[Authentication & CORSExactly what happens to each incoming request when JWT authentication or cross-origin rules are turned on. The two protection mechanisms in full, what the calling system has to do, how to read what arrives, and the gotchas worth knowing.](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors)

## Customization

[Custom Records & FieldsHow to shape Flexie around the things your business actually tracks. Add your own fields to records and create entirely new record types, then link them together.](https://flexie.io/resources/customization/custom-records-and-fields)

## Data Quality

[Data QualityHow Flexie keeps your customer records clean, accurate, and free of duplicates, spotting near-matches on its own and merging duplicates without losing history.](https://flexie.io/resources/data-quality/overview)

## Integrations

[Integrations & Developer AccessHow Flexie connects to the rest of your software, and how developers and outside AI assistants connect securely to Flexie. Two-way data exchange, dynamic endpoints, and granular access control.](https://flexie.io/resources/integrations/integrations-and-api)

## Security

[Accounts, Teams & SecurityHow to manage the people in your Flexie account and keep everything secure. Roles, ownership, two-step sign-in, the activity record, and controls over every outside connection.](https://flexie.io/resources/security/accounts-and-security)

---

## Activity & oversight

Source: https://flexie.io/resources/ai/activity-and-oversight

# Activity & oversight

Last updated 6 June 2026

![An AI activity log listing what was asked, what the assistant did, who ran it and when, and what each request cost](https://flexie.io/image/resources/ai-activity-and-oversight.png)

When the assistant takes an action, it leaves a trail, the same as a person would. Nothing it does is hidden or off the books, which gives you a clear answer to "what did the AI do, and why?" long after the fact.

## What is recorded

For the assistant's activity you can see:

* **What was asked** and the answer it gave.
* **What it did**: the abilities it used and the records it touched.
* **When** it happened, and who was using it at the time.
* **Its thinking**, where step-by-step reasoning was on, so you can see how it reached an answer.
* **What it cost**, so usage is easy to monitor and budget.

Changes the assistant makes to your records and knowledge bases also appear in the ordinary history of those records, attributed to the assistant, so they sit right next to changes made by people.

## Why it matters

* **Trust.** You can verify the assistant behaved correctly, rather than taking it on faith.
* **Troubleshooting.** If an answer looked wrong, you can see exactly what it did and where it went astray.
* **Accountability.** Automated actions are as reviewable as manual ones.
* **Cost control.** Usage is visible, so there are no surprises.

## Nothing is lost to a refresh

The assistant's conversations and its pending requests are preserved. If you close the panel or refresh the page in the middle of something, you come back to where you were: a half-approved action is still waiting for your decision, and completed work is still in the conversation.

## Closely related

* [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety): the controls that sit in front of every action.
* [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security): the wider audit log and permissions.
* [Settings & models](https://flexie.io/resources/ai/settings-and-models): decide what the assistant may do in the first place.

---

## AI in workflows

Source: https://flexie.io/resources/ai/ai-in-workflows

# AI in workflows

Last updated 6 June 2026

![A workflow where a new deal triggers an AI Agent step that reviews the deal and branches to all clear or flagged for review, running the same way for every deal](https://flexie.io/image/resources/ai-ai-in-workflows.png)

Place the AI inside an automated process as a step, and it does its job unattended, the same way every time, for the whole business rather than one person at a time. Because it is a step in a process, it can react to a record, run on a schedule, and pass its answer on to the steps that follow.

## How it works

You add an **AI Agent** step to a workflow and give it a job, written in plain words: "review this deal and flag any risks," "draft a reply to this support message," "summarise what happened today." From then on, every time the automation runs, the AI does that job automatically, with no one watching.

## Setting up an AI step

The step gives you everything you need to define the job:

| Setting                   | What it does                                                                                                                                                     |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **AI provider & model**   | Which AI powers this step.                                                                                                                                       |
| **Task**                  | The job to do this run, in plain words. You can weave in details from the record being processed, so each run is about the right customer or deal.               |
| **Instructions**          | The standing brief: who the AI is and how it should behave for this step.                                                                                        |
| **Abilities**             | Which abilities this step is allowed to use, chosen per step. See [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do).                                     |
| **Knowledge bases**       | Which of your knowledge bases this step may draw on. See [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases).                                                       |
| **How many steps**        | A limit on how much work it may do in one run, so it always finishes in good time.                                                                               |
| **Memory**                | Optionally let it remember context from one run to the next.                                                                                                     |
| **Live updates**          | Optionally stream its progress to a connected screen as it works, useful for chat-style experiences you build yourself.                                          |
| **Answer format**         | Either a **structured** answer (clean fields that later steps can read precisely) or a **free-text** answer (natural writing, ideal for messages and summaries). |
| **Where the answer goes** | The answer is saved under a name you choose, so any later step in the workflow can use it.                                                                       |

## What people build with it

* **Audit new records.** When an important deal or customer is created, the AI reviews it and flags anything unusual for a person to check.
* **Draft replies.** When a support case arrives, the AI reads it and prepares a suitable response for the team.
* **Generate written briefings.** On a schedule, the AI looks at live business data and writes a summary: a daily or weekly briefing produced on its own.
* **Make context-based decisions.** Where a process needs judgement that is more than a simple rule, the AI weighs it up and the workflow branches on its answer.
* **Enrich and clean data.** As records arrive, the AI fills gaps and tidies them.

## Why it is different from chatting

Chatting helps one person, one request at a time. An AI step works for the whole business, continuously.

* It runs as a reliable, repeatable step, the same way every time.
* It can be placed in many workflows at once, each with its own job.
* It works unattended: overnight, on weekends, while your team is offline.
* It handles one record or thousands without slowing down.

## Staying in control

You decide, in advance, exactly which abilities and which knowledge bases each AI step may use, so an unattended step only ever works within the limits you set. The answer it produces flows into the rest of your workflow, where your normal rules and conditions take over. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## Closely related

* [Workflow automation](https://flexie.io/resources/workflows/overview): the engine the AI step runs in.
* [AI by text & WhatsApp](https://flexie.io/resources/ai/by-text-and-whatsapp): a workflow that answers messages with AI.
* [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases): give an AI step your own facts to work from.

---

## Approvals & safety

Source: https://flexie.io/resources/ai/approvals-and-safety

# Approvals & safety

Last updated 6 June 2026

![A Flexie AI approval card; before it changes data it pauses for Approve or Decline, while a read-only request to show overdue invoices runs freely](https://flexie.io/image/resources/ai-approvals-and-safety.png)

When the assistant is about to do something that changes your data, such as sending a message, creating or updating records, or switching on an automation, it does not just do it. It shows you a clear summary of what it intends to do and waits. Reading and searching, which change nothing, simply happen.

## It asks before anything important

For any action that alters your data, you get two choices:

* **Approve**: the assistant carries the action out and continues.
* **Decline**: the action is cancelled and the assistant moves on.

Read-only requests, such as looking something up or running a report, do not need approval.

## You decide what needs approval

Approval is not all-or-nothing. For each ability, an administrator can decide whether it should pause for a go-ahead or run freely. A common setup is to let the assistant read and search freely, but require approval for anything that sends a message or changes a record. You set this in [Settings & models](https://flexie.io/resources/ai/settings-and-models) under "Require Confirmation".

## You can step away and approve later

When the assistant is waiting on your approval, the request is held for you. You can close the panel, refresh the page, switch to other work, or come back later, and the pending request is still there waiting for your decision. It is kept for a couple of days, which is plenty of time to come back to it.

Once you approve, the action runs and its result stays in the conversation, so a refresh never strands a half-finished request or loses what the assistant did.

## It only ever uses your permissions

This is the most important safety rule, and it is not optional. When someone uses the assistant, it inherits **that person's** permissions. It can only view or act on the records they could already reach by hand. It is never granted elevated access, and it cannot be used as a way around your permission settings. If a user cannot see a record, neither can the assistant while that user is driving it.

See [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security).

## You decide who can use it

An administrator chooses which users or teams are allowed to use the assistant at all. Everyone else simply does not have it. Combined with the permission rule above, this gives you two independent dials: **who** may use the AI, and **what** each of them can reach through it.

## A note on your data and the AI provider

Flexie's AI works by connecting to an AI provider you choose and trust. To answer a request, the relevant business data for that request is sent to that provider to be processed under their privacy and security terms. Flexie makes this explicit when you enable the AI, so the decision is a deliberate one. You choose the provider, and you choose what the assistant is allowed to do. See [Settings & models](https://flexie.io/resources/ai/settings-and-models).

## The same rules everywhere

These protections apply no matter how you use the AI:

* **In chat**, you see and approve each plan.
* **By text message or WhatsApp**, it confirms before acting.
* **In a workflow**, you decide in advance which abilities the AI step may use, so it runs unattended only within the limits you set.

Nothing important happens unapproved or outside your rules.

## Closely related

* [The chat assistant](https://flexie.io/resources/ai/chat-assistant): where you see and approve plans.
* [Settings & models](https://flexie.io/resources/ai/settings-and-models): set which abilities need approval and who can use the AI.
* [Activity & oversight](https://flexie.io/resources/ai/activity-and-oversight): review everything the AI has done.

---

## AI by text & WhatsApp

Source: https://flexie.io/resources/ai/by-text-and-whatsapp

# AI by text & WhatsApp

Last updated 6 June 2026

![A WhatsApp chat where you ask how the week went and the assistant replies with closed deals and unpaid invoices, then sends 14 reminders when you ask it to chase the late payers](https://flexie.io/image/resources/ai-by-text-and-whatsapp.png)

You do not have to be at your desk, or even open Flexie, to put the AI to work. You can do it from the messaging app already on your phone. You text it the way you would text a colleague, it does the work inside Flexie, and it replies.

## How it works

You set this up once, as a small automation with three pieces:

From then on, every message to that number reaches the AI. The exact same setup works for WhatsApp.

## What you can do by message

* **Ask for live numbers.** "How many deals closed this week? What's unpaid?"
* **Trigger actions.** "Remind every customer with an overdue invoice to pay."
* **Update records.** "Add a note to the Johnson deal: they want to start in March."

## You stay in control

Because it is built as an automation, you decide the details:

* **Which number** it answers on.
* **What the AI is allowed to do** through it, the abilities you grant the step.
* **Which messages** it should respond to, by filtering out anything that should not reach it.

The same safety rules apply as everywhere else. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## Why it matters

* **No app, no login.** It works through plain text messages and WhatsApp.
* **It works from anywhere.** On the road, on site, between meetings.
* **It is instant.** Answers come back before you have put your phone away.

For owners and managers who are rarely at a desk, this turns the whole platform into something you run from your pocket.

## Closely related

* [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows): the AI step that reads the message and writes the reply.
* [Communication & Inbox](https://flexie.io/resources/inbox/overview): setting up the text and WhatsApp channels.

---

## The chat assistant

Source: https://flexie.io/resources/ai/chat-assistant

# The chat assistant

Last updated 6 June 2026

![A Flexie AI chat where the user asks for a follow-up to last week's quotes and the assistant prepares it, shows the plan, and confirms it was sent to 12 contacts after approval](https://flexie.io/image/resources/ai-chat-assistant.png)

There are no commands to learn and no special syntax. You open the assistant from anywhere in Flexie, type what you need the way you would say it to a capable colleague, and it does the work, showing you its plan before anything that changes your data.

## Asking for things

Plain words are enough. You can be as casual or as precise as you like, and more specific requests get more precise results.

* "Which customers haven't bought in six months?"
* "What's the total value of my open pipeline?"
* "Draft a follow-up to everyone who got a quote last week."
* "Add a 'contract end date' field to all my customers."
* "When an invoice is two days overdue, send the customer a reminder."

If a request is unclear, the assistant asks a short follow-up rather than guessing.

## Watching it work

The assistant answers as it goes, rather than making you wait for a wall of text at the end. As it works you can see what it is doing: looking something up, preparing a message, building a report. You are never left staring at a blank screen wondering whether anything is happening, and you can tell at a glance whether it understood the request.

## It remembers the conversation

As you work, the assistant keeps track of what matters: your earlier questions, the records you are focused on, and the way your business is set up. So you can say "now do the same for last month" or "send that to the second customer instead" and it understands. Each answer builds on the last, the way a real conversation does.

When you want a clean slate, start a new conversation. The assistant then sets the previous thread aside and begins fresh.

## Thinking things through

For anything beyond a simple lookup, the assistant can think a problem through step by step before it answers, which produces more careful, more reliable results on harder requests. An administrator can turn this on or off for the whole account in [Settings & models](https://flexie.io/resources/ai/settings-and-models); it is on by default. Turning it off makes simple jobs faster and cheaper.

## Sharing files with it

You can attach a file to a message, such as a document, a spreadsheet, or an image, and ask the assistant to work with it: "pull the contact details out of this," "summarise this contract," "what does this screenshot show?" Whether files can be attached depends on the AI model your account is connected to; the option appears when the connected model supports it.

## It asks before anything important

Before the assistant does something that changes your data, such as sending a message, creating or updating records, or switching on an automation, it shows you exactly what it is about to do and waits for your approval. You read the plan, then say go, or decline. Read-only requests, like looking something up, just happen. This is covered fully in [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## You can step away and come back

If the assistant is waiting for your approval, you do not have to act immediately. You can close the panel, refresh the page, or come back later, and the request is still there waiting for your decision. Once you approve something and it runs, the result stays in the conversation. Nothing is lost to a refresh.

## It plays by your rules

The assistant can only see and do what your own account permits. It is not a back door to data you could not otherwise reach: it inherits your permissions exactly. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety) and [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security).

## Tips for the best results

* **Be specific.** "Show me overdue invoices from customers in Paris" beats "show me invoices."
* **Build on your last message.** You do not need to repeat context; just continue.
* **Review before approving.** The assistant shows you its plan. Read it, then say go.
* **Ask it to explain.** Not sure how a feature works? Just ask the assistant.

## Closely related

* [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do): the full ability set.
* [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases): give the assistant your own facts to draw on.
* [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows): the same assistant, working unattended.

---

## Connecting outside assistants

Source: https://flexie.io/resources/ai/connect-outside-assistants

# Connecting outside assistants

Last updated 6 June 2026

![An outside AI tool connected to Flexie through a secure open standard so it can look up records, run reports, and trigger automations, while staying signed in, within permissions, and revocable](https://flexie.io/image/resources/ai-connect-outside-assistants.png)

If your team already works in an AI assistant elsewhere, Flexie can safely open its abilities to it, so that assistant can look up customers, run reports, and trigger automations in Flexie, without anyone leaving the tool they are in.

## What it does

Flexie can present its abilities to an outside AI assistant through the open industry standard for connecting AI assistants to business software. Once connected, that assistant can do the same kinds of things Flexie's own assistant does: find records, run a report, start an automation, all by asking, from within the assistant your team already uses.

## It stays just as safe

Opening Flexie to an outside assistant does not loosen any of your protections:

* **Secure sign-in.** The outside assistant has to be authorised first, through a proper sign-in and consent step. It cannot connect quietly.
* **Same permissions.** It works within the permissions of the account it connected as. It cannot reach anything that account could not reach by hand.
* **Same approvals.** Actions that change data still go through Flexie's approval rules.
* **You can revoke it.** Access can be withdrawn at any time, cutting the outside assistant off.

## Why teams use it

* **Work where you already are.** Pull Flexie's data and actions into the AI tool your team has standardised on.
* **One source of truth.** The outside assistant reads live Flexie data, not a stale copy.
* **No custom build.** Because it uses an open standard, connecting is configuration, not a development project.

## Closely related

* [Integrations & developer access](https://flexie.io/resources/integrations/integrations-and-api): connecting Flexie to your other tools.
* [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety): the permission and approval rules that still apply.
* [The chat assistant](https://flexie.io/resources/ai/chat-assistant): Flexie's own built-in assistant.

---

## Knowledge bases (Brains)

Source: https://flexie.io/resources/ai/knowledge-bases

# Knowledge bases (Brains)

Last updated 6 June 2026

![A Flexie Brain called Support Playbook with categories for Installation, Billing, and Common Errors, and a document for resetting a password that the assistant can read and follow related links from](https://flexie.io/image/resources/ai-knowledge-bases.png)

Out of the box, the assistant knows your records and your setup. A knowledge base, called a **Brain** in Flexie, adds the things that are not stored as records: how your business does things, the fine print of your offering, the way you like replies written. Give the assistant a Brain and its answers become grounded in your own material instead of general knowledge.

## Why use one

A knowledge base grounds the assistant in your own approved material. Instead of answering from general knowledge, it answers from your product details, your policies, your playbooks, and the answers you have already written, applied consistently every time.

## How a knowledge base is organised

Three simple levels, plus links between entries:

* A **knowledge base (Brain)** is the whole library, on one subject, for example "Product Manual" or "Sales Playbook".
* A **category** groups related documents inside it, for example "Billing" or "Onboarding".
* A **document** is one entry: a clear title and its content, in plain, lightly formatted text.
* Documents can **link to related documents**, so the assistant can follow a topic from one entry to the next, the way you would follow cross-references.

## Building one by hand

The Brain page is a simple three-column manager:

1. **Knowledge bases** on the left. Create one, give it a name and a short description.
2. **Categories** in the middle for the selected knowledge base.
3. **Documents** on the right: pick a category, then add and edit its documents in a clean reader-and-editor view.

You can search within a knowledge base to find an entry quickly, and build up a web of related documents as the library grows.

## Locked vs. editable

Each knowledge base is either **editable** or **locked (read-only)**:

* **Editable** knowledge bases are living. The assistant may add and update entries in them when you allow it.
* **Locked** knowledge bases are reference material. The assistant can read them, but never change them. Use this for material that should only ever be curated by a person.

## What the assistant does with a knowledge base

When a knowledge base is assigned to an assistant, it can:

* **Discover** which knowledge bases it has and what categories they hold.
* **Search** for the most relevant documents and see a short snippet of why each matched.
* **Read** a document in full, and follow its related links to dig deeper.
* **Add and update** documents and categories, in editable knowledge bases only, and after the usual approval.
* **Import in bulk**, turning a long block of text into many documents in one go, split by its headings. Re-importing the same titles updates those entries rather than creating duplicates.

The assistant can only reach the knowledge bases it has been assigned, and it can only change the ones that are not locked.

## Assigning knowledge bases to an assistant

A knowledge base does nothing until you give it to an assistant. You choose which knowledge bases each can use:

* For the **main assistant** and each **specialist**, in [Settings & models](https://flexie.io/resources/ai/settings-and-models).
* For an **AI step in a workflow**, on that step itself. See [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows).

When an assistant has knowledge bases assigned, a short summary of them is woven into its instructions, so it knows what it can look things up in.

## A worked example

You sell software and support is answering the same setup questions over and over. You create a **"Support Playbook"** knowledge base, with categories like _Installation_, _Billing_, and _Common Errors_, and a document for each recurring question. You assign it to the assistant that drafts support replies. From then on, when a case comes in, the assistant searches the playbook, reads the relevant entry, and drafts a reply grounded in your own approved answers, not a guess.

## Closely related

* [Specialists](https://flexie.io/resources/ai/specialists): give a focused helper its own knowledge base.
* [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows): assign a knowledge base to an unattended AI step.
* [Settings & models](https://flexie.io/resources/ai/settings-and-models): assign knowledge bases to the main assistant and specialists.

---

## Overview

Source: https://flexie.io/resources/ai/overview

# Overview

Last updated 6 June 2026

![The Flexie AI assistant carrying out a request end to end; it found 14 overdue invoices, drafted a reminder, sent them, and paused one large account for approval](https://flexie.io/image/resources/ai-overview.png)

Most "AI assistants" are a chat box bolted onto the side of a product. They can talk about your data, but they cannot touch it. Flexie's AI is part of the platform. You ask for something in plain words and it does the work, inside your own account and always within your permissions: looking things up, building automations, writing reports, tidying records, and taking action.

The short version: you ask, and it does, after showing you the plan.

## The four ways to put it to work

The same assistant works in four places. Most businesses use all four.

| Way                           | What it is                                                           | Best for                                                                |
| ----------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| **Chat**                      | Open the assistant and ask for things in plain words.                | Hands-on work, one request at a time.                                   |
| **Inside a workflow**         | Drop an AI step into an automated process so it runs unattended.     | Repeatable jobs across the whole business: audits, drafting, briefings. |
| **By text or WhatsApp**       | Text the assistant from your phone and get answers and actions back. | When you are away from a desk.                                          |
| **From an outside assistant** | Safely open Flexie's abilities to an AI assistant you use elsewhere. | Teams that already work in another AI tool.                             |

## What it is made of

Four building blocks work together behind the single assistant you talk to.

* **Abilities** are the concrete things it can do: find records, send an email, build an automation, prepare a document, and more. See [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do).
* **Knowledge bases (Brains)** are your own curated facts the assistant can read and, when you allow it, update. See [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases).
* **Specialists** are focused helpers the assistant quietly hands the heavy jobs to. See [Specialists](https://flexie.io/resources/ai/specialists).
* **Approvals** keep you in control: nothing important happens without your go-ahead. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## What's in this section

1. [The chat assistant](https://flexie.io/resources/ai/chat-assistant): talking to the AI inside Flexie, watching it work, the conversation memory, attaching files, and starting fresh.
2. [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do): the full set of abilities in plain language, from finding data to building automations and managing your setup.
3. [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety): how it asks before anything important, how it stays inside your permissions, and who is allowed to use it.
4. [Knowledge bases (Brains)](https://flexie.io/resources/ai/knowledge-bases): building your own libraries of facts the assistant can search, read, and keep up to date.
5. [Specialists](https://flexie.io/resources/ai/specialists): the focused helpers behind the scenes, and how to set them up.
6. [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows): placing an AI step inside an automation so it works unattended.
7. [AI by text & WhatsApp](https://flexie.io/resources/ai/by-text-and-whatsapp): running the assistant from the messaging app on your phone.
8. [Settings & models](https://flexie.io/resources/ai/settings-and-models): connecting the AI, choosing models, turning abilities on or off, and access control.
9. [Connecting outside assistants](https://flexie.io/resources/ai/connect-outside-assistants): opening Flexie's abilities to an AI assistant you use elsewhere.
10. [Activity & oversight](https://flexie.io/resources/ai/activity-and-oversight): the record of everything the AI has done.

## One thing to know up front

The assistant never works around your rules. It can only see and change what the person using it is already allowed to see and change, and it asks for approval before anything that alters your data. You decide which abilities it has, which ones need a confirmation first, and which people are allowed to use it at all.

## Closely related

* [Workflow automation](https://flexie.io/resources/workflows/overview): where the AI step lives.
* [Communication & Inbox](https://flexie.io/resources/inbox/overview): the text and WhatsApp channels the AI can answer on.
* [Dashboards & Reports](https://flexie.io/resources/reports/overview): the AI can design and save reports for you.
* [Integrations & developer access](https://flexie.io/resources/integrations/integrations-and-api): connecting outside assistants.

---

## Settings & models

Source: https://flexie.io/resources/ai/settings-and-models

# Settings & models

Last updated 6 June 2026

![The Flexie AI settings panel showing the main model set to a provider, reasoning on, abilities toggled on with send email needing approval, and access limited to the sales team](https://flexie.io/image/resources/ai-settings-and-models.png)

Everything that shapes the assistant lives in one place: which AI powers it, which abilities it has, what needs approval, which knowledge bases it draws on, and who is allowed to use it. Configuring the AI is an administrator task.

## Connecting the AI

Flexie's AI runs on an AI provider you connect. Under **AI Vendors & Models** you add one or more, each with:

* **Name**: a label for this connection.
* **Vendor**: the AI provider (OpenAI, Anthropic, or DeepSeek).
* **Model**: which of that provider's models to use.
* **API Key**: the credential from your provider account that authorises Flexie to use it.
* **Organization**: an extra account detail required by some providers.

You can connect more than one, which lets you use different models for different jobs.

> **A note on your data.** When you enable the AI, you are authorising the provider you chose to process the business data involved in each request, under their privacy and security terms. Choose a provider you trust. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## The main model

You pick one connection as the **main model**: the AI that powers the everyday assistant your team chats with. This is the workhorse, so most accounts choose a strong, well-rounded model here.

## Specialists

Below the main model you can add **specialists**: focused helpers for big, specific jobs. Each has its own model, its own selected abilities, its own short brief, and its own knowledge bases. The main assistant calls on them automatically. See [Specialists](https://flexie.io/resources/ai/specialists).

## Abilities and approvals

Two settings govern what the assistant can do:

* **Agent Tools**: turn each ability on or off. Only the abilities you switch on are available. See [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do).
* **Require Confirmation**: for any ability, decide whether it must pause for the user's go-ahead before it acts. A common choice is to let reading and searching run freely while anything that sends a message or changes a record waits for approval. See [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety).

## Knowledge bases

Under **Brains**, choose which of your knowledge bases the assistant can read and, where they are editable, update. Only the knowledge bases you select here are available to it. See [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases).

## Reasoning

**Enable Reasoning** lets the model think a problem through step by step before it answers, which improves results on harder requests. It is on by default. Turning it off makes simple jobs faster and cheaper.

## Who can use the assistant

Finally, you choose which **users or teams** are allowed to use the AI at all. Everyone else simply does not have it. This works hand in hand with the core safety rule: when a permitted user runs the assistant, it inherits **that user's** existing permissions, so access is set by two independent dials.

See [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security).

## Closely related

* [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety): the rules these settings enforce.
* [Specialists](https://flexie.io/resources/ai/specialists): set up focused helpers.
* [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases): build the libraries you assign here.
* [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security): users, teams, and permissions.

---

## Specialists

Source: https://flexie.io/resources/ai/specialists

# Specialists

Last updated 6 June 2026

![The main Flexie assistant handing a job to a Reports specialist and bringing the finished report back into the conversation, while you keep talking to one assistant](https://flexie.io/image/resources/ai-specialists.png)

Some jobs are bigger than others. When a request needs deep, focused work, the assistant quietly hands it to a **specialist** built for exactly that task, lets it do the focused work, and brings the result back into your conversation. From where you sit it is seamless: you asked one assistant, and you got an answer.

## What a specialist is

Think of the main assistant as a capable generalist and a specialist as an expert it can call on. A specialist is set up for a single kind of work, for example building complex automations or designing detailed reports, and it is given its own focus, its own abilities, and its own knowledge.

## Why it works better

A specialist helps in two ways:

* **Focus.** A helper set up for one kind of job, with instructions and knowledge tuned to it, does that job better than a generalist juggling everything.
* **Clarity.** The heavy back-and-forth of a big task happens inside the specialist, so your main conversation stays clean and easy to follow. You see the outcome, not the scaffolding.

## What you can configure

Each specialist has its own settings, so you can shape it for its job:

* **Model.** Which AI model powers it. You might use a faster model for simple specialists and a stronger one for demanding work.
* **Abilities.** Which abilities it is allowed to use, chosen independently from the main assistant. See [What the assistant can do](https://flexie.io/resources/ai/what-it-can-do).
* **Instructions.** A short brief describing the specialist's role and how it should work.
* **Knowledge bases.** Which of your knowledge bases it can draw on. See [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases).

You can have several specialists, each for a different kind of work.

## When it happens

You do not trigger a specialist yourself, and you do not need to know they exist to use the assistant. The main assistant decides when a request is worth handing off, based on the kind of work involved. For everyday questions it just answers; for the demanding, focused jobs it brings in the right helper.

## Closely related

* [Settings & models](https://flexie.io/resources/ai/settings-and-models): add specialists and set their model, abilities, instructions, and knowledge.
* [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases): give a specialist its own library of facts.
* [The chat assistant](https://flexie.io/resources/ai/chat-assistant): where it all comes together as one conversation.

---

## What the assistant can do

Source: https://flexie.io/resources/ai/what-it-can-do

# What the assistant can do

Last updated 6 June 2026

![The Flexie AI ability set shown as a list; find your data, take action, build automations, manage your setup, and reach beyond Flexie, each one able to be turned on or off](https://flexie.io/image/resources/ai-what-it-can-do.png)

The assistant works through a set of **abilities**, each one a concrete thing it knows how to do inside Flexie. Every ability can be turned on or off for your account, and any of them can be set to ask for your approval before it runs. Whatever is switched on, the assistant only ever acts within the permissions of the person using it.

## Finding and understanding your data

* **Search your records.** Find and filter customers, leads, deals, invoices, cases, or any record type, and get a straight answer with no filters to build by hand. It can also save a search as a reusable report. See [Reports](https://flexie.io/resources/reports/overview).
* **Understand how your data is organised.** It knows the shape of your account, which record types and fields exist, so it can answer questions about your own setup and build accurate searches.
* **Read your deal pipelines.** It understands your stages and can reason about what is where in the pipeline.
* **Use your categories.** It can read and work with the category labels you use to organise records.

## Managing your setup

* **Work with custom fields.** It can see your existing fields and create new ones, so you can say "add a 'contract end date' field to all my customers" and it is done.
* **Work with custom record types.** It can see and create your own record types, shaping Flexie around how your business actually works.

The assistant discovers what already exists before it changes anything, so it adds to your setup rather than duplicating it.

## Taking action on records

* **Send email.** It can prepare and send messages on your behalf, after approval.
* **Prepare documents.** It can produce a PDF, such as a quote or a letter, from your templates and data.
* **Act on the page you are on.** Where appropriate, it can carry out an action on the screen in front of you.
* **Clean up duplicates.** It can find duplicate records and help you merge them. See [Data Quality](https://flexie.io/resources/data-quality/overview).

## Building automations

* **Build a workflow.** Describe a process in plain words and the assistant designs the whole automation, ready for you to review and switch on.
* **Explore what automations can do.** It can look up the full range of triggers, actions, and decisions available, so the automations it builds use the right pieces.

See [Workflow automation](https://flexie.io/resources/workflows/overview).

## Using your own knowledge

* **Search and maintain your knowledge bases.** The assistant can look things up in the libraries of facts you have given it, follow links between related entries, and, where you allow it, add and update entries. See [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases).

## Reaching beyond Flexie

* **Look things up on the web.** It can browse the web to research a company, verify a detail, or gather context.
* **Call another system.** It can send a request to an outside service you use, to fetch or push information.
* **Collect a structured choice.** It can present a small form when it needs you to pick from options or fill specific fields, rather than guessing.

## Quality checks

* **Check its own logic.** When it writes an expression or a rule, it can validate that the logic is sound before relying on it, so the automations it builds are correct.

## Behind the scenes

* **Bring in a specialist.** For big, focused jobs, the assistant hands the work to a specialist helper built for that task. You still only talk to one assistant. See [Specialists](https://flexie.io/resources/ai/specialists).
* **Learn its own abilities.** It can look up detailed guidance on how to use a given ability well, so it uses each one correctly.

## How abilities are controlled

| Control              | What it does                                                              | Where                                                    |
| -------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------- |
| **On / off**         | Decide which abilities the assistant has at all.                          | [Settings](https://flexie.io/resources/ai/settings-and-models)            |
| **Require approval** | Make a given ability pause for your go-ahead before it acts.              | [Settings](https://flexie.io/resources/ai/settings-and-models)            |
| **Permissions**      | The assistant can only ever do what the person using it could do by hand. | [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety) |
| **Per workflow**     | An AI step in a workflow gets its own selected set of abilities.          | [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows)         |

## Closely related

* [Approvals & safety](https://flexie.io/resources/ai/approvals-and-safety): what needs your go-ahead, and the permission rules.
* [Knowledge bases](https://flexie.io/resources/ai/knowledge-bases): give the assistant your own facts.
* [AI in workflows](https://flexie.io/resources/ai/ai-in-workflows): pick the abilities an unattended AI step may use.

---

## Cases & Support

Source: https://flexie.io/resources/crm/cases-and-support

# Cases & Support

Last updated 22 May 2026

![A Flexie support queue showing cases with open, in progress, and resolved statuses](https://flexie.io/image/resources/communication-cases-and-support.png)

A **case** is a customer question or problem you are tracking to resolution, what other tools call a support ticket. Cases turn "someone needs help" from a message that might get forgotten into a job with an owner, a status, and a clear finish line.

## Where cases come from

A case can start from a customer message, a form, your team, or automation:

## Working a case

Each case keeps everything about the issue together:

* The customer it belongs to, with their full history
* A description of the problem or question
* Its **status**, so you always know what is open, in progress, or resolved
* An **owner**, the team member responsible for it
* Every message exchanged about it

The team works the case until it is resolved, and nothing slips, because the case holds the whole thread in one place.

## Replying on any channel

A customer might have asked by email but prefer a text reply, or the other way round. From inside a case you can reply on whichever channel suits, and the whole back-and-forth stays attached to the case. The customer gets a smooth experience; your team keeps one tidy record.

## A clear support queue

Because every case has an owner and a status, your support work becomes an organised queue rather than a scramble. Everyone can see what is open, what is assigned to them, and what still needs attention.

## Automating support

Automation makes support faster and more consistent:

* Send an instant "we have received your request" reply.
* Assign new cases to the right team member automatically.
* Notify a manager when a case has been open too long.
* Follow up with the customer after a case is resolved.

See [Workflow Automation](https://flexie.io/resources/workflows/overview).

## Templates for faster replies

Save your common answers as templates so your team can respond to frequent questions in seconds, with consistent wording.

## Measuring your support

Build dashboards and reports to understand how support is going: cases opened and resolved, how long they stay open, and which team members are handling what. See [Dashboards & Reports](https://flexie.io/resources/reports/overview).

## Just ask Flexie AI

* "Show me all open cases that have not been updated in three days."
* "How many cases did we resolve last month?"
* "Build an automation that alerts a manager when a case stays open over 48 hours."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Inbox](https://flexie.io/resources/inbox/overview): where many cases begin.
* [Workflow Automation](https://flexie.io/resources/workflows/overview): automate your support flow.
* [Forms](https://flexie.io/resources/forms/overview): let customers raise cases themselves.

---

## Contacts & Leads

Source: https://flexie.io/resources/crm/contacts-and-leads

# Contacts & Leads

Last updated 22 May 2026

![A Flexie contact profile with a single unified activity timeline](https://flexie.io/image/resources/crm-contacts-and-leads.png)

Everyone you do business with lives in Flexie as a record. **Leads** are potential customers you have not won yet, **contacts** are people you do business with, and **companies** are the organisations those people belong to. Each record is the home for everything about that person or business: their details, their deals, their invoices, and every message you have exchanged.

## Capturing leads

Leads can reach Flexie in several ways:

* **From a form on your website:** a visitor fills it in and a lead is created instantly. See [Forms](https://flexie.io/resources/forms/overview).
* **Added by your team:** type in a lead after a call or a meeting.
* **In bulk:** bring in a list of leads you already have.
* **Automatically:** automation can create leads from other events.

However a lead arrives, Flexie can assign it to the right salesperson straight away, so it never sits unattended.

## Turning leads into customers

When a lead becomes a real customer, it moves on to become a contact, keeping its full history. Nothing is lost in the handover; the conversation simply continues.

## The customer timeline

This is the heart of every record. Open any contact and you see a **timeline**, a single ordered history of everything that has ever happened:

* Emails, texts, and WhatsApp messages
* Deals created and won
* Quotes and invoices sent
* Notes your team has added
* Tasks and appointments

Anyone on your team can open a customer and instantly know the full story, without asking around or searching other apps.

## Organising your customers

Keep large customer lists under control:

* **Search:** find anyone in seconds.
* **Filters:** narrow your list by any detail, such as location, status, or owner.
* **Smart lists:** save a filter you use often as a reusable list, for example "customers in a city" or "leads added this month."
* **Tags and categories:** label customers in your own way.
* **Owners:** every customer can have an owner, so it is always clear who is responsible.

## Adding your own details

The standard fields will not cover everything your business needs to know. You can add your own: a preferred contact method, a birthday, a customer reference number, anything. See [Custom Records & Fields](https://flexie.io/resources/customization/custom-records-and-fields).

## Linking records together

A contact can be linked to their company, their deals, their invoices, and any custom records you track. These links mean the full picture is always one click away.

## Keeping your list clean

Duplicate records are the enemy of a good customer list. Flexie watches for them automatically and helps you merge duplicates into one clean record. See [Data Quality](https://flexie.io/resources/data-quality/overview).

## Notes and tasks

On any customer you can:

* **Add notes:** capture what was said on a call or in a meeting.
* **Create tasks:** set yourself or a teammate a follow-up, with a due date.
* **Schedule appointments:** book meetings tied to the customer.

## Just ask Flexie AI

Instead of building filters, just ask:

* "Show me leads from this week that nobody has contacted."
* "Which customers in a city have not bought in six months?"
* "Add a referral source field to all contacts."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Deals & Pipelines](https://flexie.io/resources/crm/deals-and-pipelines): turn customers into sales.
* [Inbox](https://flexie.io/resources/inbox/overview): talk to your customers.
* [Workflow Automation](https://flexie.io/resources/workflows/overview): automate lead follow-up.

---

## Deals & Pipelines

Source: https://flexie.io/resources/crm/deals-and-pipelines

# Deals & Pipelines

Last updated 22 May 2026

![A Flexie sales pipeline board with deal cards moving across stages](https://flexie.io/image/resources/crm-deals-and-pipelines.png)

A **deal** is a sales opportunity, a specific chance to win business from a customer. Each deal records what is on offer, how much it is worth, who is working on it, and how close it is to closing.

## The pipeline

Your **pipeline** is the visual board where deals live. It is split into **stages**, the steps a deal moves through on its way to a sale. A simple pipeline might look like this:

Each deal sits in a stage. As it progresses, you move it forward. At a glance you can see:

* How many deals are at each stage
* What each deal is worth
* Where this month's revenue is likely to come from
* Which deals are stuck and need attention

## Building your pipeline

Your sales process is your own, so your pipeline is too. Set up the stages that match how you actually sell. You can have more than one pipeline if different parts of your business sell in different ways.

## Working a deal

Open a deal and you have everything in one place:

* The customer it belongs to, with their full history
* The value of the opportunity
* The stage it is in
* Notes, tasks, and appointments
* Every message exchanged about it

Move the deal between stages as it progresses, usually by dragging it on the pipeline board.

## From deal to quote to invoice

This is where Flexie's all-in-one design pays off. When a deal is ready, you can build a quote for the customer directly from the deal, and when they approve it, turn the quote into an invoice in a click. The sale flows straight into billing with nothing re-typed.

See [Finance](https://flexie.io/resources/finance/overview).

## Never miss a follow-up

Deals are won and lost on follow-up. Flexie helps you stay on top of it:

* Set tasks and reminders on any deal.
* Use automation to create follow-up tasks automatically when a deal sits too long, or to send the customer a nudge.

See [Workflow Automation](https://flexie.io/resources/workflows/overview).

## Seeing your sales performance

Build dashboards and reports to understand your sales:

* Deals won and lost over time
* Pipeline value by stage
* Performance by salesperson
* Where your best deals come from

See [Dashboards & Reports](https://flexie.io/resources/reports/overview).

## Just ask Flexie AI

* "Which deals are likely to close this month?"
* "Show me deals that have been stuck in Negotiation for over two weeks."
* "What is the total value of my open pipeline?"
* "Build a report of deals won this quarter by salesperson."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Finance](https://flexie.io/resources/finance/overview): turn won deals into revenue, then payments, then books.
* [Workflow Automation](https://flexie.io/resources/workflows/overview): automate your follow-ups.
* [Dashboards & Reports](https://flexie.io/resources/reports/overview): measure your sales.

---

## Custom Records & Fields

Source: https://flexie.io/resources/customization/custom-records-and-fields

# Custom Records & Fields

Last updated 23 May 2026

![A Flexie contact record extended with custom fields, alongside a custom Property record type linked to its owner](https://flexie.io/image/resources/customization-custom-records-and-fields.png)

Flexie comes ready with the records most businesses need: contacts, leads, deals, invoices. But your business is unique. You probably track things no off-the-shelf CRM thinks about: properties, vehicles, projects, contracts, equipment, memberships, appointments.

This part of Flexie lets you add all of that, so Flexie holds the exact data your business runs on.

## Custom fields, your own details

A **field** is a single piece of information on a record, a name, a phone number, a date. Flexie's standard fields will not cover everything, so you can add your own.

Examples of custom fields you might add:

* A "preferred contact method" on every contact
* A "renewal date" on every customer
* A "project budget" on a deal
* A "job reference number" anywhere you need it

You add a field once, and it appears on every record of that type, ready to fill in, search by, filter on, and include in reports.

### Kinds of fields

Fields can hold different kinds of information: short text, long text, numbers, dates, yes/no choices, single-select and multi-select dropdowns, file uploads, lookups to other records, and more. You pick the kind that fits the information you are capturing.

## Custom records, your own things to track

Sometimes a field is not enough, you need a whole new **type** of thing to track. That is a **custom record type**.

Say your business manages properties. You can create a "Property" record type, give it its own fields (address, size, owner, status), and from then on Flexie has a full list of properties, just like it has a list of customers.

You can do this for anything: projects, contracts, vehicles, sites, assets, events, whatever your business runs on.

## Linking records together

Your records are not islands, they are connected. Flexie lets you link them with **lookups**:

Once records are linked, you can jump straight from one to the other, and see everything related to a record in one place: a property's owner, a project's client, a contract's deal of origin.

## Why this is powerful

When you add your own record types and fields, Flexie stops being a generic tool and becomes **your** business system. Everything else in Flexie works with your custom setup on its own:

* **[Workflow Automation](https://flexie.io/resources/workflows/overview)** can trigger on and act on your custom records.
* **[Flexie AI](https://flexie.io/resources/ai/overview)** can find, report on, and update them.
* **Dashboards and reports** can measure them.
* **[Forms](https://flexie.io/resources/forms/overview)** can collect them.

You extend Flexie once, and the whole platform extends with it.

## Day-to-day, you adjust it yourself

The structural design of your records, the fields, the types, the links, is set up during your one-time implementation, so the model fits your business from day one. From then on, day-to-day adjustments are point-and-click: add a new field, rename a label, change a dropdown's options, all on visual screens. You shape Flexie around your work without writing code or waiting for a release.

## Just ask Flexie AI

* "Add a 'contract end date' field to all my customers."
* "Create a new record type for tracking properties."
* "Link each project to the company it belongs to."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Forms](https://flexie.io/resources/forms/overview): collect custom information from customers.
* [Workflow Automation](https://flexie.io/resources/workflows/overview): automate around your custom records.
* [Dashboards & Reports](https://flexie.io/resources/reports/overview): measure your custom data.

---

## Built-In Widgets

Source: https://flexie.io/resources/dashboards/built-in-widgets

# Built-In Widgets

Last updated 25 May 2026

![The Add Widget dialog in Flexie listing built-in widget categories Deals, Email, Page Tracking, Workflows, Cases, Attachments](https://flexie.io/image/resources/dashboards-built-in-widgets.png)

Built-in widgets are listed in the **Add Widget** dialog, grouped by area. Pick one, set its parameters (time range, pipeline), choose a size, and save.

## The catalogue at a glance

## Deals

These widgets are wired into the [Deals & Pipelines](https://flexie.io/resources/crm/deals-and-pipelines) data.

| Widget                   | Visualisation | What it shows                                                          | Main parameters              |
| ------------------------ | ------------- | ---------------------------------------------------------------------- | ---------------------------- |
| **Deals created**        | Line chart    | Number of deals created over time, multi-series capable                | Time range                   |
| **Deal forecast values** | Line chart    | Forecasted deal value over time                                        | Time range                   |
| **Won vs all**           | Pie chart     | Ratio of won deals to all deals                                        | —                            |
| **Lost vs all**          | Pie chart     | Ratio of lost deals to all deals                                       | —                            |
| **Top closing users**    | Bar chart     | Users ranked by closed-won deals                                       | Time range, top-N limit      |
| **Top delayed users**    | Bar chart     | Users ranked by deals that have lingered the longest                   | Top-N limit                  |
| **Top stages**           | Bar chart     | Deal stages ranked by deal count                                       | —                            |
| **Pipeline funnel**      | Funnel chart  | The full pipeline funnel with stages from open through to won and lost | Pipeline (which one to show) |

> The **Pipeline funnel** is the flagship widget: five layered stages stacked like a funnel, with the won path coloured green and the lost path red.

### Time range parameter

For widgets that have a **time range**, you pick a window such as _"last 7 days"_, _"last 30 days"_, _"this month"_, _"this quarter"_. The widget re-computes whenever it is refreshed.

## Email

Wired into the [Inbox](https://flexie.io/resources/inbox/overview) email tracking signals.

| Widget                    | Visualisation | What it shows                                            |
| ------------------------- | ------------- | -------------------------------------------------------- |
| **Email stats over time** | Line chart    | Sends, reads, clicks (multi-series) over a chosen window |
| **Read vs unread**        | Pie chart     | Composition of email outcomes                            |
| **Click vs no-click**     | Pie chart     | Composition of click engagement                          |

## Page tracking

Wired into the page-tracking signal documented under [workflow listeners](https://flexie.io/resources/workflows/triggers-and-sources#4-listener).

| Widget                  | Visualisation | What it shows                                   |
| ----------------------- | ------------- | ----------------------------------------------- |
| **Page hits over time** | Line chart    | Hits to tracked pages                           |
| **A/B test results**    | Pie chart     | Distribution between variants in a running test |

## Workflows

| Widget                       | Visualisation | What it shows                                                       |
| ---------------------------- | ------------- | ------------------------------------------------------------------- |
| **Workflow processing time** | Line chart    | How long the runtime is taking to process workflow events over time |
| **Recent workflow activity** | Line chart    | Steps executed over time                                            |

## Cases

| Widget                    | Visualisation | What it shows                                         |
| ------------------------- | ------------- | ----------------------------------------------------- |
| **Case volume over time** | Line chart    | Cases created (and optionally resolved) over a window |
| **Cases by status**       | Pie chart     | Open, pending, solved, closed                         |

## Attachments

| Widget                        | Visualisation | What it shows                |
| ----------------------------- | ------------- | ---------------------------- |
| **Asset downloads over time** | Line chart    | Tracked attachment downloads |

## Choosing a widget

The catalogue above is the menu. For everything else, a metric that isn't on the list, a layout the built-ins don't offer, a chart you want styled a specific way, use either:

* A **[Report widget](https://flexie.io/resources/dashboards/report-widgets)**: build a saved data grid report and render it as Single value, Line, Bar, Pie, or Grid.
* A **[Custom HTML widget](https://flexie.io/resources/dashboards/custom-html-widgets)**: build a saved HTML report and drop the whole rendered page into the dashboard.

The point is that you are never blocked by the built-in catalogue: the report-driven widgets cover every dashboard need that has well-defined data, and HTML widgets cover every need that doesn't.

## Common parameters

A few parameters appear on many widgets:

* **Time range**: _"last 7 days"_, _"last 30 days"_, _"this week"_, _"this month"_, _"this quarter"_, _"this year"_. Always evaluated in your account's timezone.
* **Top-N limit**: for example "Top 10 closers". Default is usually 10; larger values may need a bigger widget size to render legibly.
* **Pipeline**: for deal widgets, which pipeline to use. If you only have one, this is implicit.

## What you can't change

* The **visualisation** of a built-in widget is fixed. _"Top closing users"_ is always a bar chart; you can't switch it to pie. If you need the same data drawn a different way, build a report-driven widget instead.
* The **underlying query** is fixed too. Built-ins are part of the product. If you need the metric calculated differently (different time-window definition, different exclusion rule), build a report and use a report widget.

## Next steps

* [Report widgets](https://flexie.io/resources/dashboards/report-widgets): turn a saved data grid report into a widget.
* [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets): turn an HTML report into a widget that can show anything.

---

## Custom HTML Widgets

Source: https://flexie.io/resources/dashboards/custom-html-widgets

# Custom HTML Widgets

Last updated 25 May 2026

![A Flexie dashboard with a custom HTML widget rendering three KPI tiles, a heatmap, and a leaderboard inside one tile](https://flexie.io/image/resources/dashboards-custom-html-widgets.png)

When the built-in widgets and the six Report visualisations aren't enough, drop in an [HTML report](https://flexie.io/resources/reports/html-reports) as a widget. Because the HTML report can do anything HTML can do, combined with the full [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) toolkit, **you can build any widget you can imagine**.

## How it works

1. You create an [HTML report](https://flexie.io/resources/reports/html-reports) (Reports → New → Output format = **HTML**) with a template that produces exactly the layout you want: KPI cards, custom charts, multi-section grids, anything.
2. Once that report is **published**, it appears in the dashboard's "Add widget" menu under **Reports**, just like a data grid report, but with a distinct subtype: **HTML**.
3. When you add it as a widget, no further visualisation choices are needed (no axes, no value columns). The whole rendered template _is_ the widget.

The widget renders its HTML inside its tile on the dashboard. Inside that tile, anything goes: your styles, your JavaScript, your custom mini-charts.

## Why this matters

The dashboard's built-in chart engine renders **line, bar, pie, and funnel**. That is already a lot. But if you want:

* **Three KPIs in one tile.** Sales, leads, NPS, side by side, each with its own colour and trend arrow.
* **A heatmap, a treemap, a Sankey**, anything outside line/bar/pie/funnel.
* **A custom layout**, a table on the left, a chart on the right, captions underneath.
* **A "kanban-as-a-widget"**, columns drawn from your data.
* **A live status board**, colour-coded cards with conditional formatting.
* **Embedded media**, a PDF preview, a video, an image gallery driven by your data.

…**none of those fit a pre-defined visualisation type**. With an HTML widget, the visualisation is whatever you write, including pulling in third-party chart libraries via a `<script src="…">`.

## A worked example, a three-up KPI tile

A single widget showing three KPIs side-by-side, each with its own colour and a small caption.

### Step 1, create the HTML report

Reports → New → Output format = **HTML**. Paste this into the template field:

```html
<style>
  .kpi-row { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1rem; }
  .kpi     { padding: 1rem; border-radius: 8px; color: #fff; text-align: center; }
  .kpi.green  { background: #16a34a; }
  .kpi.blue   { background: #1d4ed8; }
  .kpi.orange { background: #ea580c; }
  .kpi-num  { font-size: 2rem; font-weight: 700; line-height: 1; }
  .kpi-lbl  { font-size: .75rem; opacity: .9; margin-top: .35rem;
              text-transform: uppercase; letter-spacing: .04em; }
</style>

<div class="kpi-row">
  <div class="kpi green">
    <div class="kpi-num">{{ findCount("deal", "is_won", 1) }}</div>
    <div class="kpi-lbl">Won deals (all-time)</div>
  </div>
  <div class="kpi blue">
    <div class="kpi-num">{{ findCount("lead", "is_published", 1) }}</div>
    <div class="kpi-lbl">Active leads</div>
  </div>
  <div class="kpi orange">
    <div class="kpi-num">{{ findCount("case", "status", "open") }}</div>
    <div class="kpi-lbl">Open cases</div>
  </div>
</div>

```

Name it _"Quick KPIs"_, save, **publish**.

### Step 2, add it as a widget

Dashboard → **Add widget** → category **Reports** → pick _Quick KPIs_. Set the widget size to e.g. **50% × 215px**. Save.

The dashboard now has a three-up KPI tile that pulls live counts whenever it refreshes.

## What you can use inside

Everything Flexie Scripting offers is available, see [HTML reports: what the template can use](https://flexie.io/resources/reports/html-reports#what-the-template-can-use) for the full list. The most useful for widgets:

* **`findCount(...)` / `findSum(...)`**, straight-to-the-database aggregates, best for "big number" tiles.
* **`query("SELECT ...")`**, when you need a small list of rows for a custom layout.
* **`getDealStats`, `getInvoiceStats`, `getCaseStats`**, bundles of figures for an entity, returned in one call.
* **`now()`, `date(...)`, `dateAdd(...)`**, labelling and "last-X-days" windows.
* **`formatCurrency`, `numberFormat`, `truncate`**, presentable values.
* **`qrCode`**, embed a live, data-driven QR code into a widget.

For a list of records to render as your own custom layout:

```html
{% set hot = query("
  SELECT name, amount, stage_id
  FROM   deals
  WHERE  is_won = 0 AND is_lost = 0
  ORDER  BY amount DESC
  LIMIT  5
") %}

<h3>Hot deals</h3>
<ul style='margin: 0; padding-left: 1.2rem;'>
  {% for d in hot %}
    <li>{{ d.name }} — {{ d.amount | number_format(0) }}</li>
  {% endfor %}
</ul>

```

## Adding a custom chart

You can pull in any JavaScript charting library by `<script src>` and feed it data straight from a `query(...)`:

```html
<div id="chart" style="height: 220px;"></div>
<script src="https://cdn.example.com/some-chart-lib.min.js"></script>
<script>
  const data = {{ query("
    SELECT month, sales
    FROM   monthly_sales
    WHERE  year = 2026
    ORDER  BY month
  ") | json_encode | raw }};

  new SomeChartLib(document.getElementById('chart'), {
    type: 'heatmap',
    data
  });
</script>

```

`| json_encode | raw` is the safe way to embed a server-computed value inside a `<script>` block. It produces a properly-escaped JSON literal that can't break the JavaScript on quotes, newlines, or non-printable characters. See the note on [Security](https://flexie.io/resources/reports/html-reports#security-what-to-keep-in-mind).

## Sizing and refresh

Custom HTML widgets follow the same sizing model as any other widget: pick a width (`25 / 50 / 75 / 100%`) and a height (a preset pixel value, or **Auto** to grow with the content). Use **Auto** when your HTML's natural height is unpredictable; pick a fixed height when you want the tile to slot into a row with the same height as its neighbours.

The same **cache lifetime** mechanism applies. Set it lower for KPI tiles that need to feel live, higher for monthly summaries.

## When _not_ to use an HTML widget

* **For one of the built-in visualisations**: line, bar, pie, funnel done with a Report widget is far simpler than rebuilding it in HTML.
* **When the same simple metric is already a built-in widget**: use the built-in. HTML widgets cost more to maintain.
* **For very large data sets**: the 1,000-row cap still applies to `query(...)` and friends inside the template. Aggregate before rendering.

## Security & maintenance

Treat HTML widgets like code:

* **Restrict who can edit them.** A user with the **Edit** permission on reports can put arbitrary JavaScript in a tile every other viewer runs.
* **Always `| json_encode | raw`** anything you put inside `<script>`.
* **Always escape** anything you put into `href` or `src` with `url_encode`.
* **Don't paste opaque third-party snippets** you don't understand.

See [HTML reports: Security](https://flexie.io/resources/reports/html-reports#security-what-to-keep-in-mind) for the longer treatment.

## Next steps

* [Layout & sharing](https://flexie.io/resources/dashboards/layout-and-sharing): sizing, ordering, caching, public sharing.
* [Reports: HTML reports](https://flexie.io/resources/reports/html-reports): the data source side of this picture.

---

## Layout & Sharing

Source: https://flexie.io/resources/dashboards/layout-and-sharing

# Layout & Sharing

Last updated 25 May 2026

![A dashboard layout with widgets sized 25/25/50, 100, and 50/50 across three rows, with a public sharing link below](https://flexie.io/image/resources/dashboards-layout-and-sharing.png)

## Sizing a widget

Every widget has a **width** and a **height**.

### Width

Pick one of four values:

* **25%**: a quarter of the dashboard row
* **50%**: half a row
* **75%**: three-quarters
* **100%**: full row

Widgets flow left to right and wrap automatically. Two 50% widgets sit on one row, four 25% widgets sit on one row, a 75% followed by a 25% sit on one row, and so on.

### Height

Pick one of a handful of preset heights, or **Auto**:

* **215px**: single KPI tile / small chart
* **330px**: comfortable chart with legend
* **445px**: large chart
* **560px / 675px / 850px / 1024px**: for big dashboards-in-a-widget
* **Auto**: let the widget grow with its content (useful for HTML widgets whose natural height varies)

The preset heights make rows of mixed widgets line up tidily. Use **Auto** when a widget's content varies (for example a list whose row count changes), and match neighbours' heights when you want a clean grid.

### Choosing sizes well

A few rules of thumb:

* **Big numbers want small tiles.** A single-value KPI looks best at 215px.
* **Time-series charts want width.** 50% × 330px or wider.
* **Bar charts with many bars** need vertical room; 445px is usually right for top-10 lists.
* **HTML widgets with lots of content** are usually 100% wide with Auto height.

## Ordering widgets

Each widget has a numeric **ordering** value. Widgets are sorted by ordering ascending, then flowed left-to-right, top-to-bottom.

In practice you'll move widgets around via drag-and-drop or reorder controls on the dashboard; those update the stored ordering for you. You don't have to set the number by hand.

> Two widgets with the same ordering number tie-break by their underlying id (creation order), which is usually fine but can produce surprising results after long edit histories. If two adjacent widgets won't stay in the order you want, set their ordering values explicitly.

## The cache and refresh

Each widget has its own **cache lifetime** (in minutes):

* **`0`**: no cache; the widget recomputes every time the dashboard is opened. Use sparingly, only for KPIs you genuinely want live.
* **Any positive number**: keep the computed widget for that many minutes before recomputing.
* **Unset / default**: the system default applies (**2 hours** out of the box).

The cache is **per widget, per user context**. So:

* A dashboard with 12 widgets does not query the database 12 times every page load; only the widgets whose cache has expired recompute.
* Two users opening the same dashboard see consistent data once their cached copy has settled.

### Manual refresh

Use the dashboard's **Refresh** action to force a recompute of every widget regardless of cache. Use widget-level refresh (where available) to force a single widget.

### When to lower the cache

* **Real-time-feeling KPIs**: 1 to 5 minutes is reasonable.
* **Counts of "today's activity"**: 5 to 15 minutes.
* **Big aggregate queries**: leave them on the default 2 hours; they are expensive to compute and rarely worth recomputing more often.

## Multiple dashboards

You can build as many dashboards as you need, typically one per role or team:

* _"Sales, pipeline"_
* _"Support, case load"_
* _"Leadership, KPIs"_
* _"My personal dashboard"_

One dashboard is the **system default**, the one that opens at `/dashboard` for users who don't have a personal pinned dashboard. Mark a dashboard as the default in its settings.

Other dashboards are reached either by name from a dropdown on the dashboard page, or by direct URL (each dashboard has its own id).

## Access control

A dashboard has the same **Who can access this dashboard?** field a report does. See [Reports: Access control](https://flexie.io/resources/reports/viewing-exporting-sharing#access-control) for the long explanation. In short, you combine entries from:

* **All Users**,
* specific roles (under **Permissions**),
* **Groups**, or
* individual **Users**.

A user matching at least one entry can open the dashboard. A user matching none can't, and the dashboard won't appear in their dashboard list.

The **system default** dashboard should normally include **All Users** so anyone landing on `/dashboard` sees something useful.

## Sharing a dashboard publicly

For sharing a dashboard with someone _outside_ Flexie, a partner, an external stakeholder, a client, without giving them a login, you can publish the dashboard behind a **public signed link**.

### The link

Public dashboards are served from the URL pattern:

```
/d/{hash}

```

Where `{hash}` is a long unguessable identifier generated when you publish the share. Opening that URL renders the dashboard in a stripped-down, read-only mode: no Flexie chrome, no other dashboards, just the widgets.

### Configuring a share

When creating a public share you set:

* **The dashboard** to share.
* **An email** (optional): typically the email of the recipient, recorded for your audit trail.
* **A password** (optional): if set, the public page asks for it before rendering. Useful for sharing with someone who shouldn't be able to forward the link.
* **An expiry date** (optional): after which the link returns a "share expired" page.

### What the recipient sees

A public viewer sees the same widgets a logged-in user would, recomputed on their cache lifetimes. Widgets the recipient should _not_ see (for instance ones that show sensitive internal numbers) should be moved to a separate internal dashboard; public shares show the _whole_ dashboard.

### Revoking a share

Delete the share to revoke the link. The URL stops working immediately.

> The share's link is unguessable, but it is still a URL. If someone forwards it, anyone who has it can open it (subject to expiry or password). Treat shared dashboard URLs with the same care as you would any other link.

## Putting it all together, a sample dashboard layout

A typical sales-team dashboard, laid out:

| Row | Widgets                                     | Width           | Height |
| --- | ------------------------------------------- | --------------- | ------ |
| 1   | Won deals KPI · Pipeline value · Open cases | 25% / 25% / 50% | 215px  |
| 2   | Deals created over time (line chart)        | 100%            | 330px  |
| 3   | Top closers (bar) · Pipeline funnel         | 50% / 50%       | 445px  |
| 4   | Custom HTML widget, team leaderboard        | 100%            | Auto   |

Set the KPI tiles to a 5-minute cache; leave the long charts on the 2-hour default; set the leaderboard's cache to 15 minutes.

## Next steps

* [Built-in widgets](https://flexie.io/resources/dashboards/built-in-widgets): the catalogue of widget types.
* [Report widgets](https://flexie.io/resources/dashboards/report-widgets): turning a saved report into a widget.
* [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets): when the catalogue isn't enough.

---

## Overview

Source: https://flexie.io/resources/dashboards/overview

# Overview

Last updated 25 May 2026

![A Flexie dashboard composed of KPI tiles, a pipeline funnel, a line chart, and a custom HTML widget](https://flexie.io/image/resources/dashboards-overview.png)

A **dashboard** in Flexie is a page made of **widgets**. Each widget is a small, self-contained visualisation, a count, a chart, a list, a fully custom HTML block, and a dashboard is just a layout of these widgets on a screen.

## The shape of a dashboard

You can build several dashboards (one per team, one per role, one per topic), choose a default one, share dashboards across the company or with selected groups, and publish a dashboard publicly behind a signed link if you need to.

## The two kinds of widget

Every widget on a dashboard is one of these:

| Kind                     | Where its data comes from                                        | Examples                                                                                          |
| ------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| **Built-in widget**      | A specific feature inside Flexie                                 | "Deals created over time", "Pipeline funnel", "Email open rate", "Top closing users"              |
| **Report-driven widget** | A saved [Report](https://flexie.io/resources/reports/overview), data grid or HTML | A bespoke metric you built yourself, a custom layout, a single-value KPI from one of your queries |

Both kinds use the **same widget model**: they are configured the same way, you size and position them the same way, they refresh the same way. The difference is just where the numbers come from.

> Because **HTML reports** can run any HTML, CSS, and JavaScript with [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview), and any HTML report can be placed on a dashboard as a widget, **you can build any widget you can imagine**, well beyond the catalogue of built-ins. This is documented in detail on [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets).

## Built-in widget catalogue (preview)

Flexie ships widgets for the parts of the product you would expect, including:

* **Deals**: deals created over time, won and lost ratios, top closers, deal forecast, top stages, the **pipeline funnel**.
* **Email**: sent, read, clicked, unsubscribed over time, summary pies.
* **Page tracking**: page hits, A/B test outcomes.
* **Workflows**: processing time, recent activity.
* **Cases**: case volume, statuses.
* **Attachments**: download stats.

The complete catalogue with every widget type is in [Built-in widgets](https://flexie.io/resources/dashboards/built-in-widgets).

## Chart types

Widgets that show charts use one of these visualisations:

| Chart      | Used for                                                 |
| ---------- | -------------------------------------------------------- |
| **Line**   | A value over time, possibly with multiple series         |
| **Bar**    | Comparing categories, top N rankings, period-over-period |
| **Pie**    | Composition, share of a whole                            |
| **Funnel** | Stage-by-stage progression, most often a pipeline        |

All charts are rendered in the browser and **redraw responsively** when their container resizes. There is nothing to install on your side.

## Layout, sizing, refresh

* **Widget width** is one of `25%`, `50%`, `75%`, or `100%` of the dashboard width.
* **Widget height** is a fixed pixel value (a small set of preset heights) or **Auto**, which lets the widget grow with its content.
* Widgets are **ordered** with a numeric position, lowest first, and flow left-to-right within their row.
* Each widget has its **own cache lifetime** (in minutes). When a viewer opens the dashboard, fresh widgets render from cache; expired ones recompute. Default cache is **two hours**; for live KPIs you can set it lower.
* You can **manually refresh** the whole dashboard.

The detailed sizing, layout, and refresh rules are on [Layout & sharing](https://flexie.io/resources/dashboards/layout-and-sharing).

## Access and sharing

A dashboard has the same **Who can access this dashboard?** field a report does. You combine **All Users**, specific roles, user groups, or individual users in one list. A user matching at least one entry can see the dashboard.

In addition, a dashboard can be **shared publicly via a signed link** (`/d/{hash}`), useful for sending a snapshot to a partner or an external stakeholder without giving them a Flexie account. The link can be set to expire on a date.

Details on [Layout & sharing](https://flexie.io/resources/dashboards/layout-and-sharing#sharing-a-dashboard-publicly).

## What is in this section

1. [Built-in widgets](https://flexie.io/resources/dashboards/built-in-widgets): the complete catalogue, organised by area, with the chart type and configuration of each.
2. [Report widgets](https://flexie.io/resources/dashboards/report-widgets): using a saved data grid report as a widget; the six visualisation subtypes (single value, single number, line, bar, pie, grid) with their settings.
3. [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets): using an HTML report as a widget; the "any imaginable widget" route, with worked examples.
4. [Layout & sharing](https://flexie.io/resources/dashboards/layout-and-sharing): sizing, ordering, the cache, multiple dashboards, access control, and public sharing.

## Closely related

* [Reports](https://flexie.io/resources/reports/overview): where most non-built-in widgets get their data.
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): the language HTML widgets use.

---

## Report Widgets

Source: https://flexie.io/resources/dashboards/report-widgets

# Report Widgets

Last updated 25 May 2026

![A single saved Flexie report driving six different widget visualisations on a dashboard](https://flexie.io/image/resources/dashboards-report-widgets.png)

Whenever you save and publish a **data grid** report, Flexie automatically adds it to the dashboard's "Add Widget" menu under **Reports**. Pick the report, then choose **one of six visualisation subtypes** for how it should render. The report's query is the data source; the widget settings choose the picture.

This means:

* You only have to maintain **one** query, the report, and you can use it as many widgets as you like, in multiple ways, across multiple dashboards.
* Editing the report's query updates **every widget** that uses it.
* The report can still be opened directly at `/reports/view/{id}` for its full grid view, while the widget shows a slimmed visualisation.

## The six subtypes

When you add a Report widget, the configuration screen asks **how should this report be rendered?** with these choices:

| Subtype           | Looks like                                      | Use it for                                |
| ----------------- | ----------------------------------------------- | ----------------------------------------- |
| **Single value**  | One large number with a label below             | A "top KPI" tile                          |
| **Single number** | Same as Single value (synonym kept for clarity) | A "top KPI" tile                          |
| **Line chart**    | An X/Y line graph                               | A trend over time                         |
| **Bar chart**     | A vertical bar graph                            | A ranking, top N items by value           |
| **Pie chart**     | A pie with a legend                             | Composition, share of a whole             |
| **Grid**          | A small paginated table inside the widget       | A short list view inline on the dashboard |

The subtype is set per-widget: the same saved report can be three different widgets on three different dashboards, drawn differently each time.

## Configuring each subtype

### Single value / Single number

Picks one cell from the result and shows it.

| Setting          | Meaning                                               |
| ---------------- | ----------------------------------------------------- |
| **Value column** | The column whose value should be displayed. Required. |

Tip: write the report so it produces **one row** (typically with a `SUM(...)` or `COUNT(...)` query). Single-value widgets read row 0 of the result.

```sql
-- A report shaped for a Single-value widget:
SELECT COUNT(*) AS open_deals
FROM deals
WHERE is_won = 0 AND is_lost = 0

```

Widget settings: Value column = `open_deals`.

### Line chart

Plots an X/Y curve from two columns.

| Setting                  | Meaning                                            |
| ------------------------ | -------------------------------------------------- |
| **X-axis column**        | The horizontal-axis column (typically a date)      |
| **Y-axis column**        | The vertical-axis column (the numeric value)       |
| **Limit**                | How many rows to plot (default applies; max 1,000) |
| **Order by / direction** | Sort the rows before plotting                      |

```sql
-- A report shaped for a Line widget:
SELECT DATE(date_added) AS day, COUNT(*) AS deals
FROM deals
WHERE date_added > DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY DATE(date_added)
ORDER BY day ASC

```

Widget settings: X-axis = `day`, Y-axis = `deals`.

### Bar chart

Plots a value per category.

| Setting                  | Meaning                                                                   |
| ------------------------ | ------------------------------------------------------------------------- |
| **X-axis column**        | The category column (e.g. user name)                                      |
| **Y-axis column**        | The numeric value column (e.g. won total)                                 |
| **Limit**                | Top N to plot                                                             |
| **Order by / direction** | Almost always your numeric column DESC, to make Top N actually be the top |

```sql
SELECT u.full_name AS user, SUM(d.amount) AS total
FROM deals d JOIN users u ON u.id = d.owner_id
WHERE d.is_won = 1
GROUP BY u.id
ORDER BY total DESC

```

Widget settings: X-axis = `user`, Y-axis = `total`, Limit = 10.

### Pie chart

Plots slices labelled by one column, sized by another.

| Setting          | Meaning                                  |
| ---------------- | ---------------------------------------- |
| **Label column** | The column whose values name each slice  |
| **Value column** | The numeric column that sizes each slice |

```sql
SELECT status AS label, COUNT(*) AS count
FROM cases
GROUP BY status

```

Widget settings: Label = `label`, Value = `count`.

> Pie charts are _not_ limited in the same way Bar and Line are; you typically want to show **all** slices.

### Grid

Renders the report's data as a small table inside the widget, useful when your dashboard wants to show a short list rather than a chart.

The widget shows the report's columns; you control the row count via the widget's size (rows that don't fit are paginated).

## A worked end-to-end example

**Goal:** a "Top 10 customers by lifetime value" widget on the team dashboard.

### Step 1, build the report

Create a data grid report (`/reports/new`) with this query:

```sql
SELECT a.account_name AS customer,
       SUM(d.amount)  AS lifetime_value
FROM   deals d
JOIN   accounts a ON a.id = d.account_id
WHERE  d.is_won = 1
GROUP  BY a.id
ORDER  BY lifetime_value DESC

```

Set the **default order** to `lifetime_value DESC`. Save, publish.

### Step 2, add it to the dashboard

On the dashboard, **Add widget**, then category **Reports**, pick the report you just made.

### Step 3, configure the visualisation

* **Subtype:** Bar chart.
* **X-axis column:** `customer`
* **Y-axis column:** `lifetime_value`
* **Limit:** 10
* **Order by:** `lifetime_value`
* **Direction:** Descending
* **Width / Height:** 50% / 445px

Save. The widget now appears on the dashboard, showing the top 10 customers as a bar chart, refreshing on the cache lifetime you set.

The same report could just as easily be the data source for:

* A **Single value** widget: display the top customer's name and value.
* A **Pie chart**: show the relative share of top customers.
* A **Grid** widget: the full top-10 as a small table.

You only wrote the query once.

## When the data source changes

Edit the underlying report (different query, more columns, different sort) and every widget using it picks up the new shape on its next refresh. If you **rename a column**, widgets that reference the old name (for example as X-axis or Value column) need to be reconfigured; otherwise they error.

The 1,000-row cap and the read-only restrictions on the report's query still apply, see [Data Grid reports: What the query can do](https://flexie.io/resources/reports/data-grid-reports#what-the-query-can-do-and-what-it-cant).

## When a report widget isn't enough

If the layout you want isn't a single chart or a single table, for instance you want three KPIs in one widget, or a chart with custom labels next to it, or any non-rectangular presentation, drop down to a **[Custom HTML widget](https://flexie.io/resources/dashboards/custom-html-widgets)** instead. It uses an [HTML report](https://flexie.io/resources/reports/html-reports) as its source and gives you full control over what is rendered.

## Next steps

* [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets): when none of the six subtypes fit.
* [Layout & sharing](https://flexie.io/resources/dashboards/layout-and-sharing): sizing, caching, multiple dashboards.

---

## Data Quality

Source: https://flexie.io/resources/data-quality/overview

# Data Quality

Last updated 25 May 2026

![Two duplicate Flexie contact records merging into one clean record with the combined history](https://flexie.io/image/resources/data-quality-overview.png)

Over time, every customer database picks up **duplicates**, the same person or company entered twice. Someone is added by a teammate, then again from a website form, then again from an imported list. Flexie works to keep this from happening, and to clean it up cleanly when it does.

## Why duplicates matter

Duplicates cause real problems:

* A customer gets the same email twice
* Their history is split across two records, so nobody sees the full picture
* Your reports count the same customer more than once
* Your team wastes time figuring out which record is the "real" one

## Automatic duplicate detection

Flexie watches for duplicates on its own. When a new record looks like one you already have, a similar name, a matching phone number or email, a shared tax number, Flexie spots it and flags it.

It is smart about near-matches, too. "John Doe" and "Jon Doe," or a company entered with and without "Ltd," can still be recognised as the same. It even notices when a lead and a contact are really the same person.

When a likely duplicate is found, Flexie lets the right people know, so it gets dealt with before it causes confusion.

## Merging duplicates

When you confirm two records **are** the same, you **merge** them into one. Merging is careful by design. Flexie does not just delete one record, it combines them, so nothing is lost.

When you merge:

* The full history from both records is kept on the surviving record.
* Every deal, invoice, message, task, and note moves across.
* You choose which details to keep where the two records disagree.
* The result is one clean, complete record with the whole story.

## Nothing gets lost

A merge is a significant change, so Flexie treats it that way. The process keeps a record of what was merged, so there is always a clear history of what happened. You can merge with confidence, knowing the customer's full story stays intact.

## Keeping data clean going forward

Catching duplicates is one piece. Good data quality is a habit Flexie supports throughout:

* **Forms** can be set up to check against existing records before creating a new one. See [Forms](https://flexie.io/resources/forms/overview).
* **Required fields** make sure key information is always captured. See [Custom Records & Fields](https://flexie.io/resources/customization/custom-records-and-fields).
* **Automation** can fix common issues, standardising tags, setting missing owners, normalising phone numbers. See [Workflow Automation](https://flexie.io/resources/workflows/overview).
* **Flexie AI** can scan for messy data and propose fixes.

## Just ask Flexie AI

* "Find possible duplicate contacts in my account."
* "Show me customers missing an email address."
* "Merge these two leads, keeping the older record's email."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Contacts & Leads](https://flexie.io/resources/crm/contacts-and-leads): where your customer records live.
* [Forms](https://flexie.io/resources/forms/overview): catch duplicates at the door.
* [Flexie AI](https://flexie.io/resources/ai/overview): a fast way to spot data problems.

---

## Authentication & CORS

Source: https://flexie.io/resources/dynamic-endpoints/authentication-and-cors

# Authentication & CORS

Last updated 27 May 2026

![The endpoint listener verifying an incoming request, with green checks for issuer, signature, expiry, and origin](https://flexie.io/image/resources/dynamic-endpoints-authentication-and-cors.png)

An endpoint listener has two protection mechanisms: a JSON Web Token check that lets you reject any call not signed with your shared secret, and a cross-origin check that lets a web browser call the endpoint from your own site (and only your own site). Both are introduced briefly in [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint). This page is the deep reference for both, the exact protocol the calling system has to follow, the failure responses, the gotcha when you turn both on at once, and ready-to-adapt code samples in nine languages.

## The order things happen in

When a request hits `/listener/{first_hash}/{second_hash}` and the listener has either feature turned on, Flexie processes them in this fixed order **before any workflow step runs**:

The order matters for one specific case (combining the two), covered at the end of this page.

## JSON Web Token (JWT) authentication

A JSON Web Token is a small piece of signed text the calling system puts in a header so Flexie can verify the call is genuine. Turning this on rejects any request that does not carry a valid, in-date, correctly-signed token issued under your `endpoint_key`.

### The three settings on the listener

| Setting                 | What it is                                                                                                                                                                                           |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **add\_authentication** | On/off toggle. When on, the JWT check runs on every request.                                                                                                                                         |
| **endpoint\_key**       | The expected **issuer**, the value of the token's iss claim. Auto-generated when you first turn auth on; you can change it. Supports Flexie Scripting, so it can be a {{ ... }} resolved at runtime. |
| **endpoint\_secret**    | The **shared secret** used to sign and verify the token. Auto-generated; you can change it. Supports Flexie Scripting. To rotate, change the value and update every calling system.                  |

Both `endpoint_key` and `endpoint_secret` are resolved with Flexie Scripting at verification time, so you can pull them from configuration if you would rather not embed them in the listener form.

### Supported signing algorithms

| Allowed   | Family       | Notes               |
| --------- | ------------ | ------------------- |
| **HS256** | HMAC-SHA-256 | The standard choice |
| **HS384** | HMAC-SHA-384 |                     |
| **HS512** | HMAC-SHA-512 | Largest signature   |

**Not supported:** `RS256` / `RS384` / `RS512` (RSA), `ES256` / `ES384` / `ES512` (ECDSA), `PS256` / `PS384` / `PS512`, or `none`. Tokens signed with any of these will fail verification.

HMAC-only because the verification uses a shared secret rather than a public/private key pair, so both sides hold the same `endpoint_secret`.

### Building a token (what the calling system does)

A token is three Base64-encoded pieces, header, payload, signature, joined by dots:

```
<header>.<payload>.<signature>

```

The **payload** (the middle piece) is a small JSON object holding **claims**. Flexie requires exactly one specific claim and supports a handful more:

| Claim    | Required?    | What Flexie does with it                                                                                                                        |
| -------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| **iss**  | **Required** | Compared to your endpoint\_key. Must match exactly.                                                                                             |
| **exp**  | Recommended  | Expiry time (Unix seconds). Tokens past exp are rejected.                                                                                       |
| **iat**  | Optional     | Issued-at time. Helpful for auditing on the caller's side.                                                                                      |
| **nbf**  | Optional     | "Not before" time. Token is rejected before that moment.                                                                                        |
| **sub**  | Optional     | Subject, e.g. the user or system the token represents. Flexie ignores it for verification, but you can read it from the token in your workflow. |
| **data** | Optional     | Anything extra you want available to the workflow. See [Reading what is inside the token](#reading-what-is-inside-the-token).                   |

The **signature** is computed over the header and payload using your `endpoint_secret`.

> **In Flexie's own scripting**, building a token from a workflow is one line:
> 
> ```
> {% set token = jwtEncode({ "iss": "your-key", "exp": dateAdd(now(), 5, "minutes") }, "your-secret", "HS256") %}
> 
> ```
> 
> See `jwtEncode` in the [function reference](https://flexie.io/resources/flexie-scripting/function-reference).

### How to send the token

Either header works. Flexie checks `Authorization` first, then falls back to `token`:

```
Authorization: Bearer <token>

```

…or:

```
token: <token>

```

The `Bearer ` prefix is optional and is stripped if present (case-insensitive).

### Clock-skew tolerance

Flexie applies a **60-second leeway** to `exp` and `nbf` checks. So if your caller's clock is up to a minute off Flexie's, tokens will still be accepted. Anything beyond that is rejected as expired or not-yet-valid.

### Reading what is inside the token

A token's `data` claim, if you include one, becomes available to your workflow. Because it travels in a request header (the `Authorization` or `token` header), it is exposed under the headers namespace, and because header values are stored as a list (one entry per occurrence), you reach into it with `[0]`:

```
{# Token payload was:
   { "iss": "internal-tools",
     "exp": 1727712000,
     "data": { "tenant": "acme", "feature_flag": "beta" } } #}

Tenant: {{ __data.__headers.__jwt_data[0].tenant }}
Beta on?: {{ __data.__headers.__jwt_data[0].feature_flag }}

```

This is useful for **carrying metadata that is not part of the body**, a tenant id, a feature flag, an actor or identity, without baking it into every request body.

### How a failed verification looks to the caller

| What happened                                                          | HTTP status | Response body                                     |
| ---------------------------------------------------------------------- | ----------- | ------------------------------------------------- |
| Neither Authorization nor token header present                         | **403**     | Missing authentication token                      |
| Token could not be decoded, signature wrong, expired, or not-yet-valid | **401**     | Not authorized. Invalid or expired token. <token> |
| Token decoded, but its iss does not match endpoint\_key                | **401**     | Not authorized. Invalid key. <token>              |

The token is echoed in the failure body, useful for debugging on the caller's side, but it means **failure responses contain the token**. Treat them like sensitive data in any logs.

### Failure: the workflow does not run

If JWT verification fails, the workflow is **never reached**. There is no log row in the workflow's Activity views for the failed request, only the failure response is returned to the caller. If you need an audit trail of failed attempts, do it at the calling system's side, or proxy through a workflow that is not JWT-protected and verify the token yourself.

### Common JWT mistakes

* **Sending the raw signature instead of the full `header.payload.signature`.** A JWT is the whole three-piece string, not just the signature.
* **Algorithm mismatch.** Caller signed with HS256, but specified `RS256` in the token header. Flexie will reject it.
* **Wrong `iss`.** Typo in `endpoint_key`, or a stale issuer string after rotation.
* **Wrong secret.** Typo in `endpoint_secret`, or out of sync after rotation.
* **Clock drift over 60 seconds.** Verify with `date -u` on the calling host.
* **`exp` too tight.** For retries, give yourself enough headroom.
* **Embedding the secret in a browser or mobile app.** The secret must stay server-side. If it leaks, anyone can mint valid tokens.

## Cross-Origin Resource Sharing (CORS)

CORS is a browser-only concept. Servers calling Flexie directly (a webhook from another system, a cron from your servers) never trigger CORS. You only need to turn it on if **a web browser will call the endpoint from a different origin**, typically because your website's JavaScript posts a form straight to the endpoint.

### The two settings on the listener

| Setting           | What it is                                                                                                                                                                          |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **allow\_cors**   | On/off toggle. When on, Flexie performs the cross-origin checks and adds the CORS response headers.                                                                                 |
| **cors\_domains** | The allow-list. A **comma-separated list of origins** (e.g. https://app.example.com,https://staging.example.com), or the literal \* to allow any origin. Supports Flexie Scripting. |

### When the CORS check runs

It runs **only when all three are true**:

1. `allow_cors` is on.
2. The request carries an `Origin` header.
3. The request's `Origin` is **different from Flexie's own host** (a same-origin request skips the check entirely).

### What gets checked

* The `Origin` header is **trimmed and compared exactly** against each entry in `cors_domains` (after splitting on commas and trimming).
* If `cors_domains` is the literal `*`, any `Origin` is allowed.
* Matching is **exact**, including the scheme, host, and port. `https://app.example.com` does **not** match `http://app.example.com` or `https://www.app.example.com`.

### Response headers when allowed

Flexie adds these to the response:

```
Access-Control-Allow-Origin: <the request's Origin, echoed back>
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST, PUT, OPTIONS
Access-Control-Allow-Headers: *

```

> Even when `cors_domains` is `*`, the response header echoes back the actual request `Origin` rather than `*`. This is intentional and lets you safely send cookies and credentials.

### Preflight (`OPTIONS`) requests

A browser sends a **preflight** `OPTIONS` request before any "non-simple" cross-origin request (e.g. one with a custom header like `Authorization`, or a `Content-Type` of `application/json`). Flexie handles the preflight by returning **204 No Content** with the CORS headers. The workflow does **not** run for the preflight itself.

### When CORS rejects

If the request's `Origin` is not in the allow-list, Flexie returns **403** with an empty body. The browser will then refuse the request and surface a CORS error to the page's JavaScript console.

## Combining JWT and CORS, the preflight gotcha

This is the most important interaction to know about.

**JWT runs before CORS** in the request pipeline. That means a browser preflight `OPTIONS` request, which browsers send without an `Authorization` header, is **rejected by the JWT check** with **403 Missing authentication token** before the `OPTIONS` handler in the CORS block ever runs.

So if you turn on **both** auth and CORS expecting browser code to call the endpoint directly with an `Authorization` header, the **preflight will fail** and the actual request will never be sent.

### Practical implications and workarounds

| Your situation                                               | Recommended setup                                                                                                                                                                                                                                                                                                             |
| ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Server-to-server only (other system, cron, partner back-end) | **JWT on, CORS off.** No preflight issue; the calling server sends Authorization directly.                                                                                                                                                                                                                                    |
| Browser-only, no auth (public website form post)             | **JWT off, CORS on.**                                                                                                                                                                                                                                                                                                         |
| Browser plus your own back-end can sit in front              | **JWT on, CORS off** on Flexie. The browser calls _your_ back-end (same-origin, no CORS); your back-end calls Flexie with the JWT. This is the **recommended pattern** when you want both authentication and a browser-initiated flow.                                                                                        |
| Browser must call Flexie directly _and_ be authenticated     | Avoid Authorization (which triggers preflight). Instead send a **short-lived signed token in the request body or query string** and verify it inside the workflow with [jwtDecode and hashHmac](https://flexie.io/resources/flexie-scripting/function-reference). CORS alone protects the endpoint; the in-body token authenticates each call. |

Document this clearly in your integration handover. It surprises people every time.

## Sensitive headers are never exposed

Even when authentication is off and CORS is on, Flexie strips a few headers from what your workflow can see. **Cookies** and any **authentication credentials** carried in the request are removed before the request is logged or made available as `__data.__headers.*`.

If you need cookie-borne data inside the workflow, send it as a custom header or in the body.

## Concrete examples

### Server-to-server with JWT (the most common case)

The calling system signs a token and posts to Flexie:

```bash
# Build the token (pseudo-shell, use your language's JWT library in practice)
TOKEN=$(jwt-encode \
  --alg HS256 \
  --secret "$ENDPOINT_SECRET" \
  --claim "iss=$ENDPOINT_KEY" \
  --claim "exp=$(( $(date +%s) + 60 ))" \
  --claim "data={\"tenant\":\"acme\"}")

curl -X POST https://your-flexie/listener/abc.../def... \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "order_id": 12345, "amount": 99.50 }'

```

Inside the workflow:

```
Received order {{ __data.order_id }} for tenant {{ __data.__headers.__jwt_data[0].tenant }}

```

### Browser-initiated form post with CORS only

A public form on `https://www.example.com` posts to the endpoint:

```html
<form id="signup" method="post"
      action="https://your-flexie/listener/abc.../def...">
  <input name="email" />
  <input name="first_name" />
  <button type="submit">Sign up</button>
</form>

```

Endpoint settings: `allow_cors = on`, `cors_domains = https://www.example.com`, no JWT.

### Browser plus your back-end proxy (auth and browser combined)

```
   Browser (yoursite.com)
        │ POST /api/signup  (same-origin)
        ▼
   Your back-end
        │ Adds Authorization: Bearer <fresh JWT>
        │ POST /listener/abc.../def...
        ▼
   Flexie (JWT verified, CORS off)

```

This is the cleanest combination of "the browser submitted it" and "we know it was really us calling."

### Browser calling directly with a body-borne signed token

If you cannot put a back-end in front, sign a short-lived token on the server that loads the page, include it in the form body, and verify it inside the workflow:

```html
<input type="hidden" name="ts" value="2026-05-23T12:34:00Z">
<input type="hidden" name="sig" value="<HMAC of ts + form_id with a shared secret>">

```

Inside the workflow's first decision:

```
{# Recompute the signature and compare; reject if mismatched or older than 5 min #}
{% set expected = hashHmac("sha256", __data.ts ~ "signup-form", "your-secret") %}
{{ __data.sig == expected and dateDiff(__data.ts, now(), "minutes") < 5 }}

```

CORS is enabled (so the browser is allowed), JWT is off, and authenticity is proven by the in-body signature.

## Code samples, signing a token and sending a request

The following samples all do the same thing: **build an HS256 JWT** with `iss` equal to your `endpoint_key` and a 60-second expiry, then **POST a JSON body** to the endpoint with `Authorization: Bearer <token>`. Pick the one for your stack.

Replace the placeholder values with your real `endpoint_key`, `endpoint_secret`, and the URL Flexie generated for your listener.

### Shell (curl)

`curl` does not sign tokens itself. Sign the token with any small helper (a one-off Node or Python script, a CLI tool, your secret store) and pass it through:

```bash
TOKEN="<your signed JWT here>"

curl -X POST https://your-flexie/listener/abc.../def... \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "order_id": 12345, "amount": 99.50 }'

```

Useful for ad-hoc testing once you have generated a token elsewhere.

### Node.js (`jsonwebtoken` \+ built-in `fetch`)

```js
import jwt from 'jsonwebtoken';

const ENDPOINT_URL    = 'https://your-flexie/listener/abc.../def...';
const ENDPOINT_KEY    = 'your-endpoint-key';
const ENDPOINT_SECRET = 'your-endpoint-secret';

const token = jwt.sign(
  { data: { tenant: 'acme' } },                // your optional metadata
  ENDPOINT_SECRET,
  { algorithm: 'HS256', issuer: ENDPOINT_KEY, expiresIn: '60s' }
);

const res = await fetch(ENDPOINT_URL, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ order_id: 12345, amount: 99.50 }),
});

console.log(res.status, await res.text());

```

`jsonwebtoken` puts `iss` in the payload automatically when you pass `issuer`.

### Python (`PyJWT` \+ `requests`)

```python
import jwt
import time
import requests

ENDPOINT_URL    = 'https://your-flexie/listener/abc.../def...'
ENDPOINT_KEY    = 'your-endpoint-key'
ENDPOINT_SECRET = 'your-endpoint-secret'

token = jwt.encode(
    {
        'iss': ENDPOINT_KEY,
        'exp': int(time.time()) + 60,
        'data': {'tenant': 'acme'},
    },
    ENDPOINT_SECRET,
    algorithm='HS256',
)

response = requests.post(
    ENDPOINT_URL,
    headers={'Authorization': f'Bearer {token}'},
    json={'order_id': 12345, 'amount': 99.50},
)
print(response.status_code, response.text)

```

### PHP (`firebase/php-jwt` \+ cURL)

```php
use Firebase\JWT\JWT;

$endpointUrl    = 'https://your-flexie/listener/abc.../def...';
$endpointKey    = 'your-endpoint-key';
$endpointSecret = 'your-endpoint-secret';

$token = JWT::encode(
    [
        'iss'  => $endpointKey,
        'exp'  => time() + 60,
        'data' => ['tenant' => 'acme'],
    ],
    $endpointSecret,
    'HS256'
);

$ch = curl_init($endpointUrl);
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        "Authorization: Bearer $token",
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['order_id' => 12345, 'amount' => 99.50]),
    CURLOPT_RETURNTRANSFER => true,
]);
$response = curl_exec($ch);
$status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo $status, $response;

```

### Go (`github.com/golang-jwt/jwt/v5` \+ `net/http`)

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"

    "github.com/golang-jwt/jwt/v5"
)

func main() {
    endpointURL    := "https://your-flexie/listener/abc.../def..."
    endpointKey    := "your-endpoint-key"
    endpointSecret := []byte("your-endpoint-secret")

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "iss":  endpointKey,
        "exp":  time.Now().Add(60 * time.Second).Unix(),
        "data": map[string]string{"tenant": "acme"},
    })
    signed, err := token.SignedString(endpointSecret)
    if err != nil { panic(err) }

    body, _ := json.Marshal(map[string]any{
        "order_id": 12345, "amount": 99.50,
    })
    req, _ := http.NewRequest("POST", endpointURL, bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+signed)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()

    fmt.Println(resp.Status)
}

```

### C# / .NET (`System.IdentityModel.Tokens.Jwt`)

```csharp
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using System.Text.Json;
using Microsoft.IdentityModel.Tokens;

const string EndpointUrl    = "https://your-flexie/listener/abc.../def...";
const string EndpointKey    = "your-endpoint-key";
const string EndpointSecret = "your-endpoint-secret";

var key   = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(EndpointSecret));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

var jwt = new JwtSecurityToken(
    issuer:  EndpointKey,
    expires: DateTime.UtcNow.AddMinutes(1),
    claims:  new[] {
        new Claim("data",
            JsonSerializer.Serialize(new { tenant = "acme" }),
            JsonClaimValueTypes.Json)
    },
    signingCredentials: creds
);
var token = new JwtSecurityTokenHandler().WriteToken(jwt);

using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new("Bearer", token);

var body = JsonSerializer.Serialize(new { order_id = 12345, amount = 99.50 });
var resp = await http.PostAsync(EndpointUrl,
    new StringContent(body, Encoding.UTF8, "application/json"));

Console.WriteLine(resp.StatusCode);

```

### Java (`io.jsonwebtoken:jjwt-api` \+ built-in HttpClient)

```java
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;

public class FlexieEndpointCall {
    public static void main(String[] args) throws Exception {
        var url    = "https://your-flexie/listener/abc.../def...";
        var key    = "your-endpoint-key";
        var secret = "your-endpoint-secret";

        var keySpec = new SecretKeySpec(
            secret.getBytes(StandardCharsets.UTF_8),
            SignatureAlgorithm.HS256.getJcaName()
        );

        String token = Jwts.builder()
            .setIssuer(key)
            .setExpiration(new Date(System.currentTimeMillis() + 60_000))
            .claim("data", Map.of("tenant", "acme"))
            .signWith(keySpec, SignatureAlgorithm.HS256)
            .compact();

        var request = HttpRequest.newBuilder(URI.create(url))
            .header("Authorization", "Bearer " + token)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                "{\"order_id\":12345,\"amount\":99.50}"))
            .build();

        var response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.statusCode() + " " + response.body());
    }
}

```

### Ruby (`jwt` gem + `net/http`)

```ruby
require 'jwt'
require 'net/http'
require 'json'
require 'uri'

ENDPOINT_URL    = 'https://your-flexie/listener/abc.../def...'
ENDPOINT_KEY    = 'your-endpoint-key'
ENDPOINT_SECRET = 'your-endpoint-secret'

token = JWT.encode(
  { iss: ENDPOINT_KEY,
    exp: Time.now.to_i + 60,
    data: { tenant: 'acme' } },
  ENDPOINT_SECRET,
  'HS256'
)

uri  = URI(ENDPOINT_URL)
http = Net::HTTP.new(uri.host, uri.port).tap { |h| h.use_ssl = true }
req  = Net::HTTP::Post.new(uri.request_uri, {
  'Authorization' => "Bearer #{token}",
  'Content-Type'  => 'application/json',
})
req.body = { order_id: 12345, amount: 99.50 }.to_json

response = http.request(req)
puts response.code, response.body

```

### From inside Flexie itself (a workflow calling a protected endpoint)

If you are calling **another** Flexie endpoint (or any other system that expects the same JWT shape) **from inside a workflow**, use the Webhook action and build the token in the **Headers** field:

```
{% set token = jwtEncode(
     { "iss": "your-endpoint-key",
       "exp": dateAdd(now(), 1, "minutes"),
       "data": { "tenant": "acme" } },
     "your-endpoint-secret",
     "HS256"
) %}
Authorization: Bearer {{ token }}
Content-Type: application/json

```

The `jwtEncode` function is part of [Flexie Scripting](https://flexie.io/resources/flexie-scripting/function-reference).

### What the workflow on the receiving side reads

For any of the examples above, the receiving Flexie workflow reads the request body and the `data` claim like this:

```
Received order {{ __data.order_id }} for {{ __data.amount }}
Tenant: {{ __data.__headers.__jwt_data[0].tenant }}

```

## Failure-response cheat sheet

| Cause                                                         | HTTP | Body                                              |
| ------------------------------------------------------------- | ---- | ------------------------------------------------- |
| Missing token (add\_authentication=on)                        | 403  | Missing authentication token                      |
| Token unparseable, wrong signature, expired, or not-yet-valid | 401  | Not authorized. Invalid or expired token. <token> |
| Token issuer (iss) does not match endpoint\_key               | 401  | Not authorized. Invalid key. <token>              |
| Origin not in cors\_domains (allow\_cors=on)                  | 403  | (empty)                                           |
| Successful preflight (OPTIONS)                                | 204  | (empty, with CORS headers)                        |

## Operational checklist

Before you publish a protected endpoint:

1. **Rotate the auto-generated secret** to a value of your own and store it in your calling system's secret store.
2. **Set `exp` on every token.** Never ship long-lived tokens to clients you do not fully control.
3. **Decide who needs the `data` claim** and what it carries. Treat it like any other piece of caller-provided metadata, do not trust it for security decisions.
4. **For browser callers, settle the CORS shape first**, direct plus token-in-body, or proxy-via-your-back-end. The "Authorization + CORS preflight" combination does **not** work.
5. **Test the failure paths**, not just the happy path: missing token, expired token, wrong secret, wrong issuer, wrong origin. Each one has a distinct response.
6. **Be wary of echoed tokens in 401 bodies.** If you log responses on the calling side, redact the token from the log.

## Back to

* [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint): the settings on the listener that turn these on.
* [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data): where each piece of the request lands.
* [End-to-end examples](https://flexie.io/resources/dynamic-endpoints/examples): auth and CORS in worked round trips.

---

## Creating an Endpoint

Source: https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint

# Creating an Endpoint

Last updated 23 May 2026

![A workflow with the endpoint listener at the top, showing its URL, response type, and authentication settings](https://flexie.io/image/resources/dynamic-endpoints-creating-an-endpoint.png)

## Step 1: Create a virtual workflow

1. Open the Workflows section and choose **New**.
2. **Record type:** the **virtual** type.
3. **Source:** **Listener**.

This gives you a workflow whose starting point will be the endpoint listener.

## Step 2: Add the endpoint listener

On the builder canvas, add the **inbound endpoint** listener as the workflow's starting step. This is the block that creates and owns the public URL. It has the following settings.

### The URL (read-only)

The endpoint's address is built from two automatically-generated hashes:

```
/listener/{first_hash}/{second_hash}

```

* **`first_hash`** and **`second_hash`** are generated for you and shown read-only.
* Together they form the full public URL an external system will send data to, for example: `https://your-flexie-domain/listener/a1b2c3…/f6e5d4…`

Because the URL contains two long random hashes, it is effectively unguessable, but treat it as a secret and prefer adding authentication (below) for anything sensitive.

### Response type (required)

**`return_type`** decides what the caller gets back. There are five options:

| return\_type | What the caller receives                                                           |
| ------------ | ---------------------------------------------------------------------------------- |
| **data**     | A response body you define (JSON, XML, or HTML, the type is auto-detected)         |
| **html**     | An HTML page you define                                                            |
| **redirect** | An HTTP redirect to a URL you define                                               |
| **continue** | The response is produced **later, by a step in the workflow**, for dynamic replies |
| **sse**      | A live, streamed response (Server-Sent Events) produced by the workflow            |

These are covered fully in [Responding to the caller](https://flexie.io/resources/dynamic-endpoints/responding). For a simple "received, thanks" endpoint, choose **data** and provide a short body. The matching field appears based on your choice:

* **data:** `return_data` (the body; Flexie Scripting allowed)
* **html:** `return_html` (the HTML; Flexie Scripting allowed)
* **redirect:** `return_redirect` (the target URL; Flexie Scripting allowed)

## Step 3: Add authentication (recommended)

Turn on **`add_authentication`** to require callers to prove who they are with a **JSON Web Token (JWT)**. When enabled:

| Setting              | Meaning                                                                                                                                                          |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **endpoint\_key**    | The expected token **issuer** (the iss claim). Callers must present a token issued under this key. Auto-generated; you can change it. Supports Flexie Scripting. |
| **endpoint\_secret** | The **shared secret** used to sign and verify the token. Auto-generated; you can change it. Supports Flexie Scripting. Rotate by changing the value.             |

Details that matter when the calling system builds its token:

* Supported signing algorithms are **HS256, HS384, and HS512** only.
* A **60-second** clock-skew allowance is applied (so minor clock differences do not reject valid tokens).
* The caller sends the token in the `Authorization: Bearer <token>` header (a plain `token` header is also accepted).
* Missing token returns **403**. Invalid, expired, or wrong-issuer token returns **401**.

Without authentication, anyone who has the URL can call it. With it, only callers holding a validly-signed token for your issuer can.

> For the full protocol, claim shape, clock-skew handling, the `data` claim, failure-response details, the CORS-preflight gotcha, and ready-to-adapt code samples in Node.js, Python, PHP, Go, .NET, Java, Ruby, curl, and Flexie itself, see [Authentication & CORS in depth](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors).

## Step 4: Cross-origin rules (only if a browser calls it)

If the endpoint will be called **directly from a web browser** (from your website's front-end), enable **`allow_cors`** and list the allowed origins:

| Setting           | Meaning                                                                                                                                           |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **allow\_cors**   | Turns on cross-origin handling (including preflight requests).                                                                                    |
| **cors\_domains** | Comma-separated list of allowed origins, e.g. https://app.example.com,https://staging.example.com, or \* to allow any. Supports Flexie Scripting. |

If the endpoint is only called server-to-server (the usual case for webhooks), you do not need CORS.

> **Combining JWT auth and CORS has a real gotcha.** A browser preflight `OPTIONS` request is rejected by the JWT check because preflight does not carry `Authorization`. If you need both, route the browser call through your own back-end, or use a body-borne signature instead. See [Authentication & CORS in depth](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors#combining-jwt-and-cors-the-preflight-gotcha).

## Step 5: Build the steps, test, publish

Add the workflow's decisions and actions beneath the listener, using the incoming data as described in [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data), then **test** and **publish** as with any workflow (see [Building a workflow](https://flexie.io/resources/workflows/building-a-workflow)).

> **The endpoint only works when the workflow is published.** An unpublished virtual workflow's URL will not accept requests.

## Finding your endpoints

The public URL is shown on the endpoint listener inside its workflow. Flexie also exposes a list of published endpoints to authorised callers via a dynamic-endpoints listing, useful for an integrating system to discover what is available.

## Next steps

* [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data): how the request becomes usable values.
* [Responding to the caller](https://flexie.io/resources/dynamic-endpoints/responding): the five response types in full.
* [Authentication & CORS in depth](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors): the JWT protocol, the CORS rules, the preflight gotcha, and code samples in eight languages.

---

## End-to-End Examples

Source: https://flexie.io/resources/dynamic-endpoints/examples

# End-to-End Examples

Last updated 23 May 2026

![Four end-to-end webhook examples, a JSON acknowledgement, a website form, an authenticated lookup, and a ping vs event branch](https://flexie.io/image/resources/dynamic-endpoints-examples.png)

Complete round trips you can adapt. Each shows the incoming request, the workflow steps, the tokens used, and the response.

All examples assume a published **virtual** workflow whose starting step is the endpoint listener (see [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint)).

## Example 1: Receive a webhook and acknowledge

**Goal:** another system tells Flexie an invoice was raised; Flexie records a note on the matching contact and replies "received."

**The request the other system sends:**

```bash
curl -X POST https://your-flexie/listener/abc123…/def456… \
  -H "Content-Type: application/json" \
  -d '{
        "invoice_amount": 2500,
        "customer_email": "john@example.com"
      }'

```

**The workflow:**

1. **Decision (virtual condition):** `{{ __data.customer_email }}` **is not empty**
  * **No:** **endpoint response** action returns `{"error":"email required"}`.
  * **Yes:** continue.
2. **Action, Create a note** on the contact found by email, body: `Invoice raised: {{ formatCurrency(__data.invoice_amount, "€") }}`.
3. **Endpoint response (return\_type = data):** `{ "status": "received" }`.

**Endpoint listener settings:** `return_type` \= **continue** (so step 3 produces the reply), workflow run mode = **Sync**.

**Key point:** the body fields are read from the `__data` namespace, `{{ __data.customer_email }}`, `{{ __data.invoice_amount }}`, not at the top level.

## Example 2: Create-or-update a contact from a website form

**Goal:** your website posts a sign-up; Flexie creates the contact if new, updates it if it exists, and redirects the visitor to a thank-you page.

**The request (form-encoded, straight from a browser):**

```
POST /listener/…/…
Content-Type: application/x-www-form-urlencoded

first_name=John&last_name=Doe&email=john@example.com

```

**Endpoint listener settings:** `allow_cors` \= **on**, `cors_domains` \= `https://www.yoursite.com` (because a browser calls it directly); `return_type` \= **redirect**; `return_redirect` \= `https://www.yoursite.com/thanks?email={{ __data.email | url_encode }}`.

**The workflow:**

1. **Action, Store a value** `existing` \= `{{ findOne("contact", "email", __data.email).id | default("") }}`.
2. **Decision (virtual condition):** `{{ __data.existing }}` **is not empty**
  * **Yes:** **Update** that contact's `first_name` and `last_name`.
  * **No:** **Create** a contact from `{{ __data.first_name }}`, `{{ __data.last_name }}`, `{{ __data.email }}`.

The redirect (set on the listener) sends the visitor on regardless of branch.

> If you would rather return JSON to a front-end script than redirect, set `return_type` \= **data** and return `{ "ok": true }`.

## Example 3: A small custom lookup API (authenticated)

**Goal:** an internal tool asks Flexie for a contact's lifetime value and gets JSON back. Only the tool may call it.

**Endpoint listener settings:**

* `add_authentication` \= **on**; `endpoint_key` \= `internal-tools`; `endpoint_secret` \= a strong secret the tool also holds.
* `return_type` \= **continue**; workflow run mode = **Sync**.

**The request:**

```bash
curl https://your-flexie/listener/…/… \
  -H "Authorization: Bearer <JWT signed HS256, iss=internal-tools>" \
  -H "Content-Type: application/json" \
  -d '{ "contact_id": 42 }'

```

(The token must be signed with HS256, HS384, or HS512 and carry `iss = internal-tools`.)

**The workflow:**

1. **Endpoint response (return\_type = data):**

```json
{
  "contact_id": {{ __data.contact_id }},
  "lifetime_value": {{ findDealsValue("contact", "won", "*", __data.contact_id) }},
  "open_cases": {{ getCaseStats("contact", __data.contact_id).open }}
}

```

Because the workflow is **Sync**, the response is produced within the request and returned straight to the tool. An unauthenticated or wrongly-signed call is rejected before any step runs.

## Example 4: Branch the reply by what arrived

**Goal:** one endpoint handles both "ping" health checks and real events.

**The workflow:**

1. **Decision (virtual condition):** `{{ __data.type }}` **equals** `ping`
  * **Yes:** **Endpoint response (data):** `{ "pong": true }`.
  * **No:** process the real event, then **Endpoint response (data):** `{ "status": "processed" }`.

**Listener:** `return_type` \= **continue**, workflow run mode = **Sync**. Two different replies from one endpoint, chosen by a [virtual condition](https://flexie.io/resources/dynamic-endpoints/virtual-conditions).

## Recurring lessons from these examples

* **Body fields are under `__data`** (`{{ __data.email }}`); headers are `{{ __data.__headers.* }}`; stored values are `{{ __data.* }}`.
* **`continue` \+ Sync run mode** is the combination for request/response APIs.
* **Authenticate** anything that returns real data.
* **Enable CORS** only when a browser calls the endpoint directly.
* **Guard incoming values** with `default(...)` or `is defined`, callers do not always send what you expect.

## Back to

* [Dynamic Endpoints overview](https://flexie.io/resources/dynamic-endpoints/overview)
* [Workflows](https://flexie.io/resources/workflows/overview)
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview)

---

## Overview

Source: https://flexie.io/resources/dynamic-endpoints/overview

# Overview

Last updated 23 May 2026

![An external system POSTing data to a Flexie listener URL, becoming a virtual record, and triggering a workflow](https://flexie.io/image/resources/dynamic-endpoints-overview.png)

A dynamic endpoint is a private web address that an outside system can send data to, which instantly runs a workflow. It is how Flexie receives data from anywhere, websites, apps, partner systems, and acts on it.

Dynamic endpoints are part of the **workflow** system. Read the [Workflows](https://flexie.io/resources/workflows/overview) section first; this section builds on it.

## The idea in one picture

You create the endpoint inside a workflow. Flexie gives you a unique URL. Whenever something sends data to that URL, Flexie turns the incoming request into a record the workflow can work with, runs the workflow, and (optionally) sends a response back to the caller.

## What makes it different from a normal workflow

A normal workflow runs on a **stored record**, a lead, a deal, an invoice. A dynamic-endpoint workflow runs on a **virtual record**: the incoming request itself. There is no pre-existing row in your database; the data **is** the request that just arrived.

That is the whole reason virtual records exist: to let a workflow react to data from outside that does not (yet) correspond to anything in Flexie. The workflow can then look things up, create or update real records, send messages, call other systems, and reply, all from the data that arrived.

## When to use one

* **Receive webhooks** from another system ("a payment was made," "an order shipped," "a form on our website was filled in").
* **Accept data from your own website or app** without building a full integration.
* **Build a small custom API** backed by a workflow, receive a request, look something up or compute something, and return a response.
* **Connect tools** that can "call a URL when X happens" but do not have a native Flexie integration.

> If the data you want to act on **already lives in Flexie**, you usually do not need an endpoint. A normal [record-event workflow](https://flexie.io/resources/workflows/triggers-and-sources) is simpler. Endpoints are for data arriving from **outside**.

## How it fits together

A dynamic endpoint involves six ideas, each with its own page:

1. [Virtual entities](https://flexie.io/resources/dynamic-endpoints/virtual-entities): the "virtual record" a workflow runs on when there is no stored row.
2. [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint): making the workflow, the unique URL, and its security (authentication and cross-origin rules).
3. [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data): how the incoming request body and headers become values your steps can use.
4. [Virtual conditions](https://flexie.io/resources/dynamic-endpoints/virtual-conditions): branching the workflow on the data that arrived.
5. [Responding to the caller](https://flexie.io/resources/dynamic-endpoints/responding): the five ways to reply (including live streaming).
6. [End-to-end examples](https://flexie.io/resources/dynamic-endpoints/examples): complete round trips you can copy.

## Who this is for

This is **power-user and administrator** territory, it is where Flexie meets the wider world of web requests. You do not need to be a developer, but you will be more comfortable if terms like "POST a JSON body" and "webhook" are familiar. Everything on the Flexie side is configured in the visual workflow builder.

## Next steps

* [Virtual entities](https://flexie.io/resources/dynamic-endpoints/virtual-entities): the record type behind it all.
* [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint): the URL and its security.

---

## Receiving Data

Source: https://flexie.io/resources/dynamic-endpoints/receiving-data

# Receiving Data

Last updated 23 May 2026

![An incoming web request being parsed into the __data namespace, with body fields, headers, and earlier step values](https://flexie.io/image/resources/dynamic-endpoints-receiving-data.png)

## What Flexie accepts

When a request hits your endpoint, Flexie reads the data from wherever it is and merges it into one set of values. It walks the request in this order, taking the first that applies:

1. **Form-encoded data:** `application/x-www-form-urlencoded` (HTML form posts) or `multipart/form-data` (form posts with file uploads). Form fields are merged with the query string.
2. **A JSON body:** when the request carries JSON. Decoded and merged with the query string. Nested objects and arrays are preserved (so `order.items[0].sku` is reachable with the right token).
3. **A raw body:** anything else (plain text, XML, CSV, etc.). The whole body is wrapped under a single field so you can read it as text.
4. **The query string only:** if no body is present, just the URL parameters.

So whether the caller posts JSON, a form, or just query parameters, the fields end up in the same place. You do not configure this. It just works.

### Methods accepted

The endpoint accepts the methods you would expect a webhook receiver to be called with: `GET`, `POST`, `PUT`, and `OPTIONS` (the last one is the CORS preflight, handled automatically). The body-extraction order above applies whichever method is used.

## Where each piece lands

Everything an incoming request brings, body fields, headers, and any extras, lives under the **`__data`** namespace:

| What arrived                                                                             | How you read it in a step                       |
| ---------------------------------------------------------------------------------------- | ----------------------------------------------- |
| **A field in the request body**                                                          | {{ \_\_data.field\_name }}                      |
| **A request header**                                                                     | {{ \_\_data.\_\_headers.header\_name }}         |
| **A value an earlier step stored**                                                       | {{ \_\_data.your\_stored\_name }}               |
| **The signed-in user's id** (if the caller had a Flexie session)                         | {{ \_\_data.\_\_logged\_in\_user\_id }}         |
| **The signed-in user's name** (same condition)                                           | {{ \_\_data.\_\_logged\_in\_user\_full\_name }} |
| **Extra data carried inside the JWT** (if authenticated, and the token had a data claim) | {{ \_\_data.\_\_headers.\_\_jwt\_data\[0\] }}   |

> Body fields are **not** at the top level here. They are under `__data`. So a request body containing `email` is read as `{{ __data.email }}`, not `{{ email }}`. Headers and step-produced values are also under `__data`.

### Example

A caller posts this JSON:

```json
{
  "invoice_amount": 2500,
  "customer_email": "john@example.com",
  "customer_name": "John Doe"
}

```

Inside the workflow you read:

```
{{ __data.invoice_amount }}     → 2500
{{ __data.customer_email }}     → john@example.com
{{ __data.customer_name }}      → John Doe
{{ __data.__headers.content-type }}  → application/json

```

## Headers, and what is removed

All request headers are available under `{{ __data.__headers.* }}`, **except** a few that are stripped for security and never exposed: **cookies** and any **authentication credentials** carried in the request.

If your authentication depends on something normally carried in a cookie, send it as a custom header or as part of the body instead.

## Working with the data

Use the full [Flexie Scripting toolkit](https://flexie.io/resources/flexie-scripting/overview) on what arrived. Common needs:

**Guard against missing fields**, a caller might omit something:

```
{{ __data.customer_email | default("") }}
{% if __data.invoice_amount is defined and __data.invoice_amount %}…{% endif %}

```

**Decode a JSON value that arrived as text** (for example a nested structure passed as a string):

```
{% set order = __data.body_field | json_decode %}
First item: {{ jsonPath(order, "$.items[0].name") }}

```

**Look up a matching stored record** from an incoming value, then act on it:

```
{% set existing = findOne("contact", "email", __data.customer_email) %}
{% if existing %}
  Found contact {{ existing.id }}
{% endif %}

```

## Authenticated calls and the JWT data claim

When the endpoint has [authentication](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint) turned on, the caller's token is verified before any step runs:

* The token must be in the `Authorization: Bearer <token>` header (a plain `token` header is also accepted).
* It must be signed with **HS256, HS384, or HS512** and the listener's `endpoint_secret`.
* Its `iss` (issuer) claim must equal the listener's `endpoint_key`.
* A **60-second** allowance is given for minor clock differences between the caller and Flexie.

A token that is missing, invalid, expired, or whose issuer does not match is rejected **before** any workflow step runs. Your workflow does not even see those requests. The full protocol, the failure status codes, and code samples for building tokens in every common language are in [Authentication & CORS in depth](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors).

If the caller adds a **`data` claim** inside the token, its contents are exposed to the workflow under the headers namespace. Because header values are stored as a list (one entry per occurrence), reach into it with `[0]`:

```
{# Token's payload was { "iss":"internal-tools", "data": { "tenant":"acme" } } #}
{{ __data.__headers.__jwt_data[0].tenant }}   →  acme

```

This is useful for carrying request metadata that is not part of the body, a tenant id, a feature flag, an actor identity, without baking it into every request body.

## What lands in `__data`, summarised

| Path                                                                                      | When it is set                                                              |
| ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| {{ \_\_data.<field\_name> }}                                                              | Every request, body fields and query parameters                             |
| {{ \_\_data.\_\_headers.\* }}                                                             | Every request, all headers except cookies and credentials                   |
| {{ \_\_data.\_\_logged\_in\_user\_id }} / {{ \_\_data.\_\_logged\_in\_user\_full\_name }} | The caller arrived with a valid Flexie session                              |
| {{ \_\_data.\_\_headers.\_\_jwt\_data\[0\] }}                                             | The endpoint requires JWT auth and the caller's token included a data claim |
| {{ \_\_data.<your\_name> }}                                                               | An earlier step in the workflow stored a value under <your\_name>           |
| {{ \_\_data.\_\_entity\_inserted\_id }} / {{ \_\_data.\_\_entity\_type }}                 | An earlier step created a record                                            |

## How the data flows onward

Anything your steps **store** (with the **Store a value** action) or **produce** (a created record's id, a webhook reply) joins the same `__data` notepad and is available to later steps, exactly as in any workflow. See [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps).

So a typical endpoint workflow:

1. reads the incoming body fields (`{{ __data.… }}`),
2. looks up or creates real records from them,
3. stores any ids or values it needs (`__data.…`),
4. branches on them with a [virtual condition](https://flexie.io/resources/dynamic-endpoints/virtual-conditions),
5. and optionally [replies to the caller](https://flexie.io/resources/dynamic-endpoints/responding).

## Next steps

* [Virtual conditions](https://flexie.io/resources/dynamic-endpoints/virtual-conditions): branching on what arrived.
* [Responding to the caller](https://flexie.io/resources/dynamic-endpoints/responding): sending a reply back.
* [Authentication & CORS in depth](https://flexie.io/resources/dynamic-endpoints/authentication-and-cors): the full JWT protocol and CORS rules.

---

## Responding to the Caller

Source: https://flexie.io/resources/dynamic-endpoints/responding

# Responding to the Caller

Last updated 23 May 2026

![A workflow producing five different responses, data, html, redirect, continue, and an SSE stream](https://flexie.io/image/resources/dynamic-endpoints-responding.png)

The reply is controlled by the endpoint listener's **response type** (`return_type`), set when [creating the endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint). All response bodies support [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview), so they can include the incoming data and anything your steps produced.

## The five response types

### 1\. `data`, a body you define

Return a fixed (or token-filled) body. Flexie auto-detects whether it is **JSON**, **XML**, or **HTML** and sets the content type accordingly. Returned with HTTP 200.

Field: **`return_data`**.

```json
{ "status": "received", "ref": "{{ __data.case_ref }}" }

```

This is the default choice for webhooks: acknowledge receipt and optionally echo back an id your workflow created.

### 2\. `html`, an HTML page

Return an HTML page. Useful when a browser hits the endpoint and you want to show something.

Field: **`return_html`**.

```html
<html><body><h1>Thanks, {{ __data.first_name }}</h1></body></html>

```

### 3\. `redirect`, send the caller elsewhere

Return a redirect to a URL you specify (HTTP 302). Useful for "submit, then go to a thank-you page."

Field: **`return_redirect`**.

```
https://example.com/thank-you?ref={{ __data.case_ref }}

```

### 4\. `continue`, let the workflow decide the reply

Instead of a fixed response, the reply is produced **by a step inside the workflow**: the **endpoint response** action. Use this when the answer depends on what the workflow finds or computes, different replies down different branches.

How it works:

* Add an **endpoint response** action at the point in the tree where you know the answer. It has its own `return_type` (**data**, **html**, or **redirect**) and the matching body or URL field.
* The workflow runs, reaches that action, and the action's output becomes the caller's response.

Timing depends on the workflow's [run mode](https://flexie.io/resources/workflows/runtime-parallel-and-tree):

* **Sync workflow:** the endpoint holds the request open and returns the moment the response action fires, a true request and response.
* **Async workflow:** the endpoint waits for the response for up to **20 seconds**. If the response action fires within that window, the caller gets it; if not, the request times out. For reliable `continue` responses, prefer a **Sync** workflow so the reply is produced within the request.

### 5\. `sse`, a live, streamed response

Stream a response as a sequence of events (Server-Sent Events), for progressive output, such as a long-running computation or AI output appearing piece by piece. The workflow's steps emit frames as they run, and a final frame closes the stream.

> **`sse` requires the workflow to be in Sync mode.** An Async workflow has nowhere to stream to. Set the run mode to **Sync** before relying on streaming.

## Choosing

| You want…                                       | Use                          |
| ----------------------------------------------- | ---------------------------- |
| A fixed acknowledgement or echo                 | **data**                     |
| To show a web page                              | **html**                     |
| To bounce the caller to another URL             | **redirect**                 |
| A reply that depends on what the workflow finds | **continue** (Sync workflow) |
| Progressive or streamed output                  | **sse** (Sync workflow)      |

## A reminder on security

The response can include incoming data and computed values. Be careful not to echo back anything sensitive to an unauthenticated caller. If the endpoint returns data that matters, protect it with [authentication](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint).

## Next steps

* [End-to-end examples](https://flexie.io/resources/dynamic-endpoints/examples): responses in complete round trips.
* [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint): where the response type is set.

---

## Virtual Conditions

Source: https://flexie.io/resources/dynamic-endpoints/virtual-conditions

# Virtual Conditions

Last updated 23 May 2026

![A virtual condition decision with a left token, an operator, and a right value, branching the workflow into Yes and No paths](https://flexie.io/image/resources/dynamic-endpoints-virtual-conditions.png)

A virtual condition is one of the four workflow [decision types](https://flexie.io/resources/workflows/actions-and-decisions). It is the one you use in dynamic-endpoint (and other virtual-entity) workflows, because there are no stored record fields to filter on, only the data on the `__data` notepad and the incoming request body.

## What it does

A virtual condition compares **a value you specify** against **another value**, using an operator, and routes the record to the **Yes** or **No** branch. The values are written as [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) tokens, so they are worked out from the live data at the moment the workflow runs.

> "If the incoming `invoice_amount` is greater than 1000, go down the Yes branch."

```
{{ __data.invoice_amount }}   greater than   1000   →  Yes / No
        (left value)          (operator)    (right value)

```

The **left** value is usually a token pointing at incoming data (`{{ __data.invoice_amount }}`, `{{ __data.webhook.status }}`); the **right** value is what you are comparing against, a fixed value or another token.

## The full operator catalogue

| Operator                             | True when…                                         |
| ------------------------------------ | -------------------------------------------------- |
| equal / not\_equal                   | The two values match / do not match                |
| greater / greater\_or\_equal         | Left is larger (or equal)                          |
| less / less\_or\_equal               | Left is smaller (or equal)                         |
| greater\_than\_now / less\_than\_now | A date value is after / before the current moment  |
| between                              | Left falls within a range (you give two endpoints) |
| contains / not\_contains             | Text includes / excludes a substring               |
| begins\_with / not\_begins\_with     | Text starts / does not start with a value          |
| ends\_with / not\_ends\_with         | Text ends / does not end with a value              |
| is\_empty (also empty)               | The value is blank or null                         |
| is\_not\_empty (also not\_empty)     | The value is present                               |

> **Two names for the same thing.** `is_empty` and `empty` are accepted as the same operator at runtime, as are `is_not_empty` and `not_empty`. The builder lists the short form; AI-generated definitions sometimes use the long form. Both work.

### How values are compared, important rules

* **Numbers are compared as numbers.** `10000` is greater than `5000`. Flexie does **not** compare numeric strings character-by-character (which would wrongly make `"10000"` less than `"5000"` because `'1' < '5'`).
* **Dates are compared as dates.** A date string like `2026-05-23` is recognised and compared chronologically. Different date formats normalise to the same moment.
* **Text is compared case-sensitively.** `"Ping"` does not equal `"ping"`. If you need case-insensitive comparison, lower-case both sides with the `lower` filter: `{{ __data.type | lower }}` vs `"ping"`.
* **Tokens are resolved before comparison.** The values inside `{{ … }}` are computed first, so you can put any [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) expression in either operand, including functions and filters.

## Building one

In the workflow builder, add a **decision** and choose the **virtual condition** type. Then:

1. **Left value:** the token to evaluate, e.g. `{{ __data.invoice_amount }}` or `{{ __data.webhook.status_code }}`.
2. **Operator:** from the list above.
3. **Right value:** what to compare against (a literal like `1000`, or another token).
4. Connect the steps for **Yes** and the steps for **No** to the matching branches.

> Remember the [tree rules](https://flexie.io/resources/workflows/runtime-parallel-and-tree): a step attached to neither branch never runs.

## Reading the data correctly

Because the left value is almost always incoming data, the [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data) rules apply:

* Body fields are under `__data`, `{{ __data.invoice_amount }}`, not bare `{{ invoice_amount }}`.
* Headers are under `{{ __data.__headers.* }}`.
* Values your earlier steps stored are also under `{{ __data.* }}`.

A condition that is always taking the "No" branch is, nine times out of ten, reading the value from the wrong place (most often missing the `__data.` prefix on a body field). Check this first.

## A note for advanced or AI-built workflows

When a workflow is built by description (via Flexie AI) or imported, a virtual condition is stored with a fixed internal structure: a single rule whose comparison operands are nested together (the value-to-check and the value-to-compare-against), with the operator. The visual builder produces this structure for you, you only ever set the left value, operator, and right value. If you are constructing definitions directly, keep the operands nested as the builder does; a bare scalar in place of the operand pair will not evaluate.

## Next steps

* [Responding to the caller](https://flexie.io/resources/dynamic-endpoints/responding): replying based on the branch you took.
* [End-to-end examples](https://flexie.io/resources/dynamic-endpoints/examples): conditions in a full workflow.

---

## Virtual Entities

Source: https://flexie.io/resources/dynamic-endpoints/virtual-entities

# Virtual Entities

Last updated 23 May 2026

![An incoming request wrapped as a disposable virtual record, processed by a workflow](https://flexie.io/image/resources/dynamic-endpoints-virtual-entities.png)

Every workflow runs on a **record type**. Usually that is a real, stored type, Lead, Deal, Invoice, a custom record. A **virtual entity** is a special record type (shown as **virtual**) for workflows that react to data arriving from outside, where there is nothing stored to run on yet.

When a request hits a [dynamic endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint), Flexie wraps that request up as a virtual entity and runs the workflow against it. The workflow's steps then read the request's contents and do real work, looking up and updating stored records, sending messages, calling other systems, replying to the caller.

Think of it as a **disposable record made of the incoming data**, existing just long enough for the workflow to process it.

## What feeds a virtual entity

A virtual entity can be created from several kinds of incoming data, not only web requests. The sources Flexie supports:

* **A web request** to a dynamic endpoint (the main case, this section's focus)
* **An inbound email**
* **An inbound SMS**
* **An inbound WhatsApp message**
* **A form submission**
* **A scheduled trigger**
* **A record-deletion event**

In every case the principle is the same: some data arrives, it becomes a virtual entity, and a workflow processes it.

## The one rule to remember

A workflow whose record type is **virtual** can only use the **Listener** or **Scheduled** [sources](https://flexie.io/resources/workflows/triggers-and-sources). That makes sense: a virtual entity comes into being **because** a signal arrived (listener) or a clock fired (scheduled), there is no stored record to trigger "on create or update."

The builder enforces this. If you choose the virtual record type, you will only be offered those two sources.

## How the data is reached

Once the workflow is running on a virtual entity, the incoming data is available to your steps through [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) tokens. For a web request:

* **The body's fields** are available as `{{ __data.field_name }}`.
* **The request headers** are under `{{ __data.__headers.* }}`.
* **Anything earlier steps stored** is under `{{ __data.* }}`.

The details, how different body formats are read, and exactly where each piece lands, are on the [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data) page.

## Creating a virtual-entity workflow

1. Open the Workflows section and choose **New**.
2. For **record type**, choose the **virtual** type.
3. For **source**, choose **Listener** (for an endpoint or an inbound message) or **Scheduled**.
4. Add the endpoint listener (for web requests), see [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint), and build your steps.

## Next steps

* [Creating an endpoint](https://flexie.io/resources/dynamic-endpoints/creating-an-endpoint): the URL and its security.
* [Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data): turning the request into usable values.

---

## Accounting

Source: https://flexie.io/resources/finance/accounting

# Accounting

Last updated 26 May 2026

![A Flexie chart of accounts on the left and a journal entry on the right showing debits and credits](https://flexie.io/image/resources/finance-accounting.png)

Behind every invoice and every payment, Flexie writes the bookkeeping for you. Your books stay balanced and accurate, no separate software, no manual entry.

## Why automatic bookkeeping matters

The classic problem: your CRM tracks invoices, but your bookkeeper uses a separate accounting package. Every month, somebody copies the numbers across, makes mistakes, and the two systems drift apart.

Flexie handles both. When you finalise an invoice or record a payment, the right journal entries land in your books automatically. The customer-facing side (quotes, invoices, payments) and the accountant-facing side (chart of accounts, journal, balance sheet) are the **same data**, just viewed differently.

## The chart of accounts

The **chart of accounts** is the list of every "bucket" your business uses to track money. Each bucket is an **account**, with a **type**:

| Type            | What it tracks    | Examples                                                                         |
| --------------- | ----------------- | -------------------------------------------------------------------------------- |
| **Assets**      | Things you own    | Cash, Accounts Receivable (money customers owe you), Inventory, Office Equipment |
| **Liabilities** | Things you owe    | Accounts Payable (money you owe suppliers), Sales Tax Payable, Loans             |
| **Equity**      | The owner's stake | Owner's Capital, Retained Earnings                                               |
| **Revenue**     | Money coming in   | Sales of Hardware, Service Revenue, Consulting Income                            |
| **Expenses**    | Money going out   | Rent, Salaries, Cost of Goods Sold, Office Supplies                              |

Each account has:

* A **name** (e.g. _"Service Revenue"_).
* A **code** (e.g. _4100_), a number for ordering and matching against accounting standards.
* A **type** (one of the five above).
* A running **balance**.
* Optionally a **parent account**, to build hierarchies (e.g. _Revenue → Hardware Sales → Laptops_).

You can add accounts, rename them, organise them into hierarchies. Most accounts come with a sensible default chart based on common practice; you'll usually only need to add accounts when your business does something specific (a new revenue stream, a new expense category).

## Double-entry, in plain terms

Every financial event in your books touches **at least two accounts**, one is **debited** (increased, if it's an asset or expense) and one is **credited** (increased, if it's a liability, equity, or revenue). The two amounts are always equal, which is what keeps your books **balanced**.

You don't have to think about this when using Flexie, the system writes the entries for you. But understanding the shape helps when you read the journal or the balance sheet.

A few common shapes:

### Finalising an invoice

A £600 invoice (£500 + £100 VAT):

|            | Account             | Amount | Note                   |
| ---------- | ------------------- | ------ | ---------------------- |
| **Debit**  | Accounts Receivable | £600   | customer owes you £600 |
| **Credit** | Service Revenue     | £500   | you earned £500        |
| **Credit** | Sales Tax Payable   | £100   | you owe HMRC £100      |

Both sides total £600, balanced.

### Recording a full payment

The customer pays the £600 invoice:

|            | Account             | Amount | Note                        |
| ---------- | ------------------- | ------ | --------------------------- |
| **Debit**  | Cash (or Bank)      | £600   | £600 came in                |
| **Credit** | Accounts Receivable | £600   | customer no longer owes you |

### Recording a partial payment

The customer pays £400 of the £600:

|            | Account             | Amount |
| ---------- | ------------------- | ------ |
| **Debit**  | Cash (or Bank)      | £400   |
| **Credit** | Accounts Receivable | £400   |

Accounts Receivable now reflects £200 still owed.

### Voiding a payment

Undoing the £400 payment above:

|            | Account             | Amount | Note                           |
| ---------- | ------------------- | ------ | ------------------------------ |
| **Debit**  | Accounts Receivable | £400   | customer owes the £400 again   |
| **Credit** | Cash (or Bank)      | £400   | cash effectively goes back out |

The original entries aren't deleted, the reversal sits next to them in the journal, so the audit trail is intact.

### Credit memo

A £150 credit memo against an invoice:

|            | Account             | Amount | Note                  |
| ---------- | ------------------- | ------ | --------------------- |
| **Debit**  | Service Revenue     | £125   | revenue reduced       |
| **Debit**  | Sales Tax Payable   | £25    | VAT liability reduced |
| **Credit** | Accounts Receivable | £150   | customer owes less    |

## Down payments, the bookkeeping detail

Down payments raised through [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash) are booked correctly without you having to think about them.

When you raise a 30% deposit on a £10,000 + 20% VAT quote (so a £3,600 deposit including £600 VAT):

|            | Account                      | Amount | Note                                        |
| ---------- | ---------------------------- | ------ | ------------------------------------------- |
| **Debit**  | Accounts Receivable          | £3,600 |                                             |
| **Credit** | Customer Deposits / Advances | £3,000 | held as a liability, not yet earned revenue |
| **Credit** | Sales Tax Payable            | £600   |                                             |

The deposit sits in a **Customer Deposits** account (a liability) because the work hasn't been done yet, the customer's money is held against future delivery.

When you raise the **final balance invoice** (the one that turns all the lines into actual revenue), Flexie _moves_ the down payment from the Customer Deposits account into revenue:

|            | Account                      | Amount | Note                                         |
| ---------- | ---------------------------- | ------ | -------------------------------------------- |
| **Debit**  | Customer Deposits / Advances | £3,000 | deposit cleared                              |
| **Debit**  | Accounts Receivable          | £4,800 | balance owed for final invoice               |
| **Credit** | Service Revenue              | £6,500 | total revenue now earned (after the deposit) |
| **Credit** | Sales Tax Payable            | £1,300 | rest of VAT                                  |

End state: revenue is recognised correctly at the moment of delivery, the deposit liability is cleared, the customer's AR shows just the balance still owed.

> You don't have to set any of this up per invoice. Once your chart of accounts includes the Customer Deposits / Customer Advances account and your administrator has mapped it, the Convert to Cash flow uses it automatically.

## What each step posts

Quick reference for what touches the books and what doesn't:

| Action                     | Posts to the books?                                                     |
| -------------------------- | ----------------------------------------------------------------------- |
| Create a quote             | **No**, quotes are pre-financial.                                       |
| Edit a quote               | **No.**                                                                 |
| Cancel a quote             | **No.**                                                                 |
| Create a draft invoice     | **No**, drafts are pre-financial.                                       |
| **Finalise an invoice**    | **Yes**, AR is debited, revenue + tax are credited.                     |
| Edit a finalised invoice   | Not directly editable; use a credit memo.                               |
| **Record a payment**       | **Yes**, Cash is debited, AR is credited.                               |
| **Void a payment**         | **Yes**, the original payment entry is reversed.                        |
| **Finalise a credit memo** | **Yes**, revenue + tax are debited (reduced), AR is credited (reduced). |

## Mapping products to accounts

Each product can point to:

* A **revenue account**, where this product's revenue lands (e.g. _Hardware Sales_ or _Service Revenue_).
* An **expense account**, where the product's cost of goods sold lands (for margin reporting).
* An **inventory asset account**, where the value of stock on hand sits on the balance sheet (physical products only).

See [Products → Accounting](https://flexie.io/resources/finance/products#accounting).

You don't have to map every product. Products without explicit mappings use the account defaults set by your administrator.

## Mapping taxes to accounts

Each tax points to:

* A **sales tax account**, where output tax (what you've charged customers and owe to the tax authority) sits.
* A **purchase tax account**, where input tax (what you've paid suppliers and can reclaim) sits.

See [Taxes → Where the money goes](https://flexie.io/resources/finance/taxes#where-the-money-goes).

When you eventually pay the tax authority, record that as a payment against the sales tax account, which clears the liability.

## The Journal

The journal is the chronological list of every entry posted to your books, by invoice, by payment, by void, by credit memo. Each journal entry shows:

* The **date**.
* The **transaction type**, invoice, payment, void, credit memo.
* The **reference**, the invoice or payment number it relates to.
* The **accounts touched**, with their debit and credit amounts.
* A **description** (e.g. _"Invoice INV-1042"_).

Filter by date range, account, transaction type. Export to CSV for your accountant.

## The Balance Sheet

A point-in-time view of your business's financial position:

| Section         | Account                        | Amount        |
| --------------- | ------------------------------ | ------------- |
| **Assets**      | Cash                           | £42,310       |
|                 | Accounts Receivable            | £18,500       |
|                 | Inventory                      | £35,200       |
|                 | **Total Assets**               | **£96,010**   |
| **Liabilities** | Accounts Payable               | £4,200        |
|                 | Sales Tax Payable              | £3,650        |
|                 | Customer Deposits              | £1,200        |
|                 | **Total Liabilities**          | **£9,050**    |
| **Equity**      | Owner's Capital                | £50,000       |
|                 | Retained Earnings              | £36,960       |
|                 | **Total Equity**               | **£86,960**   |
|                 | **Total Liabilities + Equity** | **£96,010** ✓ |

The balance sheet adds up, every time, automatically, because every transaction touches two accounts with equal amounts. If yours doesn't balance, something's wrong with the data (rare; ask your administrator).

## Gotchas

* **Drafts don't count.** A draft invoice isn't in your books. Your _AR_ and _Revenue_ only reflect finalised invoices. This matters at month-end, make sure you've finalised everything before checking the books.
* **Voids and credit memos are different.** A void undoes a payment (cancels the inbound money). A credit memo undoes part of an invoice (cancels what was billed). Use whichever matches what actually happened.
* **Foreign currencies and gains / losses.** An invoice in EUR raised at one exchange rate, paid at another → the difference is recorded as a foreign-exchange gain or loss. Flexie handles this automatically.
* **Editing a finalised invoice's amount is restricted on purpose.** It would change the books retroactively. Use a credit memo or a new invoice instead, both preserve the audit trail.
* **Custom account mappings need to happen _before_ the invoice is finalised.** Changing a product's revenue account doesn't move past invoices' postings to the new account; only new invoices use the new mapping.

## Next

* [Finance overview](https://flexie.io/resources/finance/overview): the big picture.
* [Reports](https://flexie.io/resources/reports/overview): sales by month, AR aging, top customers, anything else you'd build from the data behind the journal.

---

## Convert to Cash

Source: https://flexie.io/resources/finance/convert-to-cash

# Convert to Cash

Last updated 26 May 2026

![A worked Convert-to-Cash flow turning one quote into three invoices, with the 100% running-total tracker](https://flexie.io/image/resources/finance-convert-to-cash.png)

The smart bridge from a quote to one or more invoices, including down payments, partial billing, and a guarantee that you **never invoice more than 100% of the quote total**, no matter how many times you come back.

From any quote, click **Convert to Cash** (or **Convert to Invoice**, depending on the build) to start the flow described below.

## Why this exists

A quote and an invoice almost never have a 1-to-1 relationship in real selling.

* A new project takes a **30% deposit upfront**, then the balance on delivery, two invoices off one quote.
* A long engagement gets billed **monthly in instalments**, twelve invoices off one quote.
* A retainer takes a **fixed sign-up fee** plus monthly billing, a one-off invoice plus more invoices later.

**Convert to Cash** handles all of these. You pick how much of the quote to invoice _this time_, and Flexie creates the invoice correctly: pre-filled with the right lines, the right tax, and a down-payment line where appropriate.

When you come back to the same quote tomorrow to invoice the next instalment, Flexie knows what's already been billed and only lets you bill the remainder.

## The 100% rule

Across all the invoices you raise from one quote, **the total can never exceed 100% of the quote's value**.

If the quote is for **£10,000**:

* One invoice for £4,000 → fine. (£6,000 still available.)
* A second invoice for £6,000 → fine. (£0 still available; quote is fully invoiced.)
* A third invoice for £100 → **rejected**. Flexie tells you the remaining amount is £0.

This protects you from accidentally billing the same line twice when several people work on the same deal, or when an invoicing schedule was mis-counted.

The check runs the moment you try to convert, you can't save an invoice that would push the total over 100%.

## Opening the Convert to Cash flow

From the quote's page, click **Convert to Cash**. A form opens showing:

* The quote's **total** (e.g. £10,000.00).
* The amount **already invoiced** against this quote (e.g. £2,500.00).
* The **remaining** amount available to invoice (e.g. £7,500.00).
* Your **invoicing choices** (the next section).

## The three ways to invoice

You pick one option per conversion:

### 1\. Invoice the full remaining amount

The simplest case: turn the rest of the quote into a single invoice. Every line still uninvoiced gets carried over with its quantities, prices, and taxes.

Pick this when the deal closes in one go, or when you're billing the final balance after one or more down payments.

### 2\. Invoice a percentage of the quote

A percentage of the **original quote total**, e.g. _30% down payment_, _25% per quarter_. Flexie does the maths and creates the invoice with:

* A single **down-payment line** equal to the chosen percentage of the quote total.
* The right tax applied to that line.
* The line description showing it's a percentage (e.g. _"30% Down payment, Quote Q-1042"_).

The remaining quote balance reduces by the down-payment amount, ready for the next invoice.

> **Why a single down-payment line?** Because _"30% deposit"_ isn't the same as _"invoice 30% of every line"_. Customers want to see a clean "Deposit: £3,000" on the invoice, not thirty fractional lines. Flexie books it that way too, see [Accounting](https://flexie.io/resources/finance/accounting).

### 3\. Invoice a fixed amount

A specific number, e.g. _"£2,500 this time"_. Use this when the schedule is an amount, not a percentage (project milestones sometimes work this way).

Same shape as percentage-based: one down-payment line for the amount, with the right tax applied. The remaining balance reduces by that amount.

## Down-payment lines on the invoice

When you choose **percentage** or **fixed amount**, the invoice gets a **down-payment line** instead of carrying over the quote's detailed line items.

The line looks like:

|                                  | Amount        |
| -------------------------------- | ------------- |
| Down Payment, Quote Q-1042 (30%) | £3,000.00     |
| Tax                              | £600.00       |
| **Line total**                   | **£3,600.00** |

This keeps the customer's invoice clean, they see the deposit amount, not the full project bill, and it keeps the books correct (more in [Accounting](https://flexie.io/resources/finance/accounting)).

The full quote line items only end up on an invoice when you choose **invoice the full remaining amount**, because by that point all down payments have been settled and you're billing the balance line by line.

> The **Down Payment** is a special product type in your [products library](https://flexie.io/resources/finance/products#down-payment-products). Your administrator sets it up once during account configuration. If you see an error like _"No down payment product configured"_, that's what's missing.

## A worked example

A quote for £10,000 + 20% VAT = £12,000, billed across three invoices:

### Invoice 1, 30% deposit on signing

* Choice: **percentage**, 30%.
* Quote total: £12,000.
* Down-payment amount: £3,600 (30% × £12,000, includes the tax).
* The invoice has one line: _"Down Payment, 30%", £3,000 + £600 VAT_.
* Customer's outstanding balance: **£3,600**.
* Quote shows: invoiced £3,600 of £12,000 (£8,400 remaining).

### Invoice 2, 30% on delivery

* Choice: **percentage**, 30%.
* Same maths → another £3,600 invoice.
* Customer's outstanding (across both invoices, if neither paid): £7,200.
* Quote shows: invoiced £7,200 of £12,000 (£4,800 remaining).

### Invoice 3, the balance

* Choice: **invoice the full remaining amount**.
* The remaining 40% (£4,800) needs to go out, but Flexie now switches to **detailed line items**, because this is the final invoice and the customer should see what's actually being delivered.
* All the quote's lines appear, **with the previously-billed down payments shown as deductions**, so the line totals add up to exactly £4,800.

End state: invoiced £12,000 of £12,000\. Quote is **fully invoiced**, status flips to **Invoiced**, and the convert button disappears.

## What happens to the quote

After your first **Convert to Cash** (even if it's a small down payment), the quote's status becomes **Invoiced**, and the quote is locked from edits. You can still come back to it to invoice the next instalment, the convert button keeps working until the full 100% is reached.

Once 100% is reached:

* The quote stays at **Invoiced** status.
* The Convert button goes away (or shows a "fully invoiced" message).
* The list of invoices raised from this quote remains visible on the quote's page.

## When the quote needs to change after the first invoice

This is the awkward case, the customer asks for a change after you've already billed a deposit.

**Don't try to edit the original quote.** It's locked, and your first invoice already used the old numbers anyway.

Instead:

1. Issue a **credit memo** for the original deposit invoice (if the deposit needs to be returned).
2. Create a **new quote** with the revised scope and pricing.
3. Run Convert to Cash on the new quote.

This keeps your audit trail clean and your books straight.

## A note on subscription items

Some products are **recurring** (a monthly retainer, a yearly subscription). When a quote contains those, the Convert to Cash form has an extra option, _"Create the subscription(s) only, no one-off invoice"_, to set up the recurring billing without also raising an invoice today.

The full subscription documentation will be added once that feature is complete. For now, treat subscription items on quotes the same way you'd treat any quote line, and your administrator can advise on the right convert option.

## Gotchas

* **Convert to Cash sees the quote total _including tax_.** A 30% down payment on a £10,000 + 20% VAT quote is 30% of £12,000, not 30% of £10,000\. This matches what most customers expect, _"30% deposit"_ of the total amount they owe.
* **Percentage rounding.** If a percentage doesn't divide cleanly (e.g. three invoices of one-third of £10,000), the first two invoices use the rounded amount; the final invoice catches the remainder so the total adds up exactly to 100%.
* **You can mix the modes.** Invoice 1 by percentage, invoice 2 by fixed amount, invoice 3 by full remaining. Flexie just tracks the running total, it doesn't care how you got there.
* **Deleting an unfinalised invoice frees up the amount.** A _draft_ invoice off a quote doesn't count against the 100% yet, only finalised invoices do. Delete the draft and the amount becomes available again.
* **Credit memos return amounts.** If you issue a credit memo against an invoice raised from a quote, the credited amount becomes available again on the quote's Convert to Cash, so you can re-bill the difference cleanly if scope changes.

## Next

* [Payments](https://flexie.io/resources/finance/payments): once the invoice is out, here's how you record the money coming in.
* [Accounting](https://flexie.io/resources/finance/accounting): what each step does in your books.
* [Invoices](https://flexie.io/resources/finance/invoices): the invoice-side details Convert to Cash hands off to.

---

## Invoices

Source: https://flexie.io/resources/finance/invoices

# Invoices

Last updated 26 May 2026

![A Flexie invoice showing line items, taxes, totals, and the running paid balance](https://flexie.io/image/resources/finance-invoices.png)

The bill you send a customer. Created on its own, or more often, from a quote. An invoice is the moment a sale becomes real revenue in your books.

## What an invoice is

An **invoice** is a formal request for payment. It lists what was sold, the amount owed, when it's due, and how to pay.

Unlike a quote, an invoice **is** financial. Finalising an invoice posts journal entries to your [chart of accounts](https://flexie.io/resources/finance/accounting), adds the customer's balance to your accounts receivable, and starts the clock on the due date.

## Where invoices come from

| Source                  | When                                                                                                                                         |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **From a quote**        | Most common. The customer agreed; you turn the quote into one or several invoices via [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash). |
| **Standalone (manual)** | One-off invoices, no quote was needed. Click **New** on the invoices list.                                                                   |
| **From an automation**  | A workflow action can create an invoice, see [Workflow automation](https://flexie.io/resources/workflows/overview).                                           |

The form is the same in all three cases; only the starting point differs.

## Creating an invoice manually

Click **New** on the invoices list.

### The header

| Field                      | What it does                                                                            |
| -------------------------- | --------------------------------------------------------------------------------------- |
| **Customer name**          | The person or company being billed.                                                     |
| **Customer (record link)** | Link to the contact, lead, or account, the invoice appears on their timeline.           |
| **Deal**                   | Optional, link to a deal.                                                               |
| **Purchase order**         | The customer's PO number, if they've given you one. Shown on the PDF for their records. |
| **Owner**                  | The user who owns the invoice (defaults to you).                                        |

### Addresses

Two address blocks, billing and shipping, same as on a quote. Pre-filled from the customer if you've linked one.

### Currency

| Field             | What it does                                                          |
| ----------------- | --------------------------------------------------------------------- |
| **Currency**      | The currency the invoice is in.                                       |
| **Exchange rate** | Conversion rate to your account's base currency at the time of issue. |

### Dates

| Field             | What it does                                                                                           |
| ----------------- | ------------------------------------------------------------------------------------------------------ |
| **Issue date**    | When the invoice was raised. Defaults to today.                                                        |
| **Due date**      | When payment is due. Defaults to a configurable number of days after the issue date (often _30 days_). |
| **Terms**         | Your payment terms, e.g. _"Net 30, late payment carries 1% per month."_ Shown on the PDF.              |
| **Internal note** | Notes only your team sees.                                                                             |

## Line items

Same model as a [quote](https://flexie.io/resources/finance/quotes#line-items), pick a product, override price, quantity, discount, or tax per line as needed.

The totals block at the bottom shows **Subtotal**, **Discount**, **Tax**, and **Total**, and on a finalised invoice, also **Amount paid** and **Amount due**.

### Down payment lines

Invoices created from a quote with a **down payment** carry an extra line, automatically, showing the down-payment amount and reducing the invoice subtotal. You don't add this line by hand; the [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash) flow inserts it for you.

## Invoice status

An invoice has two statuses that move independently, a **lifecycle** status and a **payment** status.

### Lifecycle status

| Status        | Meaning                                                                                                                                                         |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Draft**     | Being worked on. Not yet finalised; can still be edited or deleted without leaving a trace.                                                                     |
| **Finalised** | Locked. The invoice number is assigned, the document is sent (or downloadable), and journal entries are posted to the books. Edits are restricted from here on. |

The big difference: a **draft** invoice is invisible to your books; a **finalised** invoice is the real thing.

### Payment status

| Status             | Meaning                                                          |
| ------------------ | ---------------------------------------------------------------- |
| **Not paid**       | No payments recorded yet.                                        |
| **Partially paid** | One or more payments recorded, but the total owed isn't covered. |
| **Fully paid**     | The total has been paid off.                                     |

The payment status updates automatically as you record payments, see [Payments](https://flexie.io/resources/finance/payments).

You'll also see **Overdue** as a label on the invoice list, that's not a separate status, just a flag that the due date has passed and the invoice isn't fully paid.

## Invoice numbering

Each finalised invoice gets an **invoice number** from a sequence, typically incrementing (1001, 1002, 1003). The sequence is set up once on the account.

Draft invoices don't have a number yet. The number is assigned at the moment of finalisation, so your number sequence stays gap-free (no holes from deleted drafts).

## Sending the invoice

Same three options as a quote:

* **Download PDF.**
* **Email** with PDF attached, pick from your invoice email templates.
* **SMS or WhatsApp** with a link to the PDF.

The PDF shows your branding, the customer's details, the line items, the totals, the due date, and your payment terms.

## Credit memos (refunds and returns)

Sometimes a sale needs to come undone, the customer returns goods, gets a partial refund, or you over-billed.

That's a **credit memo**. It's an invoice with a negative effect: when finalised, it _reduces_ the customer's outstanding balance and posts reversing journal entries to the books.

To create one:

1. Open the original invoice → **Create credit memo**.
2. Adjust the lines (full credit, or just the lines being credited).
3. Finalise the credit memo.

The credit memo links back to the original invoice for traceability. Both records stay in your books; the credit memo just reverses some or all of the original.

## Editing a finalised invoice

By default, finalised invoices are locked. If you really need to correct one (e.g. a typo in the customer's name):

* **Small text changes**: your administrator can permit edits to cosmetic fields (terms, customer name).
* **Amount changes**: issue a **credit memo** for the difference and then a new invoice for the corrected amount. This preserves the audit trail.

Deleting a finalised invoice is generally not allowed, it would leave a gap in your records. The credit-memo approach handles errors cleanly.

## Workflow integration

The two events you'll most often build automations on:

* **Invoice finalised**: when a draft becomes a real invoice. Use this to send the invoice to the customer automatically.
* **Invoice paid**: when an invoice goes from _partially paid_ to _fully paid_. Use this for thank-you messages, fulfilment triggers, or a "deal closed-won" status change.

See [Workflow automation](https://flexie.io/resources/workflows/overview) for how to build automations off these events.

## Gotchas

* **Drafts can be deleted; finalised invoices can't.** That's intentional, once it's a real invoice, the audit trail matters.
* **A line's price is captured at line-time.** Changing the master product price later doesn't change existing invoices.
* **The invoice number sequence is account-wide.** If two users create draft invoices and finalise them, the numbers reflect the order of _finalisation_, not the order of _creation_.
* **The due date is just a date.** Flexie doesn't auto-charge a customer when an invoice goes overdue, but with [Workflow automation](https://flexie.io/resources/workflows/overview) you can schedule polite reminders (email, SMS, WhatsApp) at chosen intervals.
* **Foreign currency on the books.** A finalised invoice in a foreign currency uses its exchange rate to post the equivalent base-currency amount to your books. The customer still owes you the foreign-currency amount; the gain or loss when payment comes in at a different exchange rate is recorded separately.

## Next

* [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash): turning a quote into one or more invoices, including the down-payment flow and the 100% rule.
* [Payments](https://flexie.io/resources/finance/payments): recording what the customer pays.
* [Accounting](https://flexie.io/resources/finance/accounting): what finalising an invoice does to your books.

---

## Overview

Source: https://flexie.io/resources/finance/overview

# Overview

Last updated 26 May 2026

![A simplified flow from Deal through Quote, Invoice, and Payment, with the books posting from the invoice and payment steps](https://flexie.io/image/resources/finance-overview.png)

Quotes, invoices, payments, and the bookkeeping underneath them. One connected flow that starts with the deal you're closing and ends in your chart of accounts, with no separate accounting tool to keep in sync by hand.

## How the pieces fit together

The **deal** is upstream, it lives in [CRM](https://flexie.io/resources/crm/deals-and-pipelines), where a salesperson tracks the conversation that leads to a price offer. The **quote** is the offer itself, still pre-financial, it doesn't touch the books. **Invoices** and **payments** are the financial steps; only those two post to the chart of accounts.

**Products** and **taxes** sit alongside the cycle as the catalog and the rates that feed the lines on a quote or invoice. They're not steps in the flow, they're what the steps draw from.

## What's in this section

**The cycle**

1. [Quotes](https://flexie.io/resources/finance/quotes): building a quote from line items, the status flow (draft → sent → invoiced), discounts at line or quote level, currency, expiration dates, and the PDF you send to the customer.
2. [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash): the smart bridge from quote to invoice. Three ways to invoice (full, percentage, fixed amount), down-payment handling, multiple invoices per quote, and the **100% rule** so Flexie never lets you invoice more than the quote is worth.
3. [Invoices](https://flexie.io/resources/finance/invoices): invoices on their own and invoices from a quote. The status flow (draft → finalised) and payment state (not paid → partially paid → fully paid). Invoice numbering, due dates, credit memos for returns and refunds.
4. [Payments](https://flexie.io/resources/finance/payments): recording partial or full payments against an invoice. Methods (bank, card, cash), references, voiding a payment, and how the invoice's payment state updates as money comes in.
5. [Accounting](https://flexie.io/resources/finance/accounting): the chart of accounts, the double-entry bookkeeping that runs under every invoice and payment, the journal and ledger views, and how to map products and taxes to specific accounts.

**The building blocks** (what lines on a quote or invoice draw from)

1. [Products](https://flexie.io/resources/finance/products): what you sell. Physical products with stock tracking, or services priced by the hour, day, or job. How to set up a product's price, unit, tax, and the accounts its revenue should land in.
2. [Taxes](https://flexie.io/resources/finance/taxes): defining tax rates once and applying them across products and lines. Tax-inclusive vs. tax-exclusive pricing, sales tax vs. purchase tax, tax classes for export and domestic sales.

## Two things to know up front

### Quotes don't post to the books

A quote is just an offer. Until it becomes an invoice, nothing lands in your chart of accounts. This is by design: customers haggle, quotes get revised, some never close. Your books shouldn't reflect revenue until an invoice exists.

### One quote can become many invoices

The convert-to-cash flow is built around the reality that a single sale often gets billed in stages, _deposit now, balance on delivery_ or _25% on signing, 25% each quarter_. You can keep coming back to the same quote and invoice the next slice, and Flexie keeps the running total straight.

When everything's been billed (whether in one invoice or six), the quote's status becomes **Invoiced**.

## What this section deliberately doesn't cover

* **Subscriptions**: the recurring-billing feature isn't covered here yet. We'll add it once it's complete.
* **Banking and reconciliation**: bank-feed import and matching payments against bank statements live in a separate section.
* **Tax filing and returns**: the data needed for tax returns is in your books, but generating jurisdiction-specific tax-return forms isn't part of Flexie's Finance area today.

## Closely related

* [Workflow automation](https://flexie.io/resources/workflows/overview): automate invoice reminders, payment thank-yous, status changes.
* [Reports](https://flexie.io/resources/reports/overview): sales reports, AR aging, revenue by category, top customers.
* [Inbox](https://flexie.io/resources/inbox/overview): send invoices and quotes as PDFs over email, SMS, or WhatsApp.

---

## Payments

Source: https://flexie.io/resources/finance/payments

# Payments

Last updated 26 May 2026

![A Flexie invoice with two recorded payments and the running paid-vs-due balance](https://flexie.io/image/resources/finance-payments.png)

Recording the money that comes in against your invoices. Partial or full, multiple payments per invoice, with the payment status updating itself as you go.

## What a payment is

A **payment** is one piece of money received against one invoice. It has:

* An **amount**, what came in.
* A **date**, when it came in.
* A **method**, how it came in (bank transfer, card, cash).
* A **reference**, an external identifier (bank transaction id, cheque number) for your records.

An invoice can have **many payments**: a deposit followed by the balance, monthly instalments, partial settlements. Each one is a separate record, and Flexie keeps track of the running total against the invoice.

## Recording a payment

From the invoice page, click **Record payment**. A small form opens.

| Field             | What it does                                                                                                                |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
| **Amount**        | How much was received. Pre-filled with the remaining balance, adjust down for a partial payment.                            |
| **Payment date**  | When the payment arrived. Defaults to today.                                                                                |
| **Method**        | _Bank_ (transfer / direct deposit), _Online_ (card, gateway payment), _Cash_, or _Other_.                                   |
| **Reference**     | An external identifier, bank transaction id, cheque number, gateway reference. Helps you reconcile against bank statements. |
| **Received from** | (Optional) Who actually sent the money, when it's not obvious from the invoice. E.g. _"Paid by parent company"_.            |
| **Notes**         | Free-text notes, visible internally, not shown to the customer.                                                             |

Save → the payment is recorded against the invoice.

## The "never more than what's owed" check

Flexie won't let you record a payment bigger than the invoice's remaining balance. If you try, the form shows an error:

> **You added an amount greater than the invoice balance, which should be £750.00.**

This protects you from typos and accidental over-payment records. If you genuinely _did_ receive more (e.g. the customer overpaid), record the actual invoice amount as one payment, and handle the excess separately, either as a credit memo to refund it, or as an open balance to apply to the next invoice.

## How the invoice status updates

As payments come in, the invoice's **payment state** updates automatically:

| When                                         | Status             |
| -------------------------------------------- | ------------------ |
| No payments yet                              | **Not paid**       |
| One or more payments, but total < amount due | **Partially paid** |
| Payments total = amount due                  | **Fully paid**     |

You see the running totals at the bottom of the invoice:

|                | Amount      |
| -------------- | ----------- |
| Total          | £1,200.00   |
| Amount paid    | −£400.00    |
| **Amount due** | **£800.00** |

Each payment shows up as a row on the invoice's **Payments** tab: date, amount, method, reference, who recorded it.

## Partial payments

Common patterns Flexie handles cleanly:

### A deposit followed by the balance

Customer pays 30% on signing, 70% on delivery. Two payments against the same invoice, first one at _partially paid_, second one finishes at _fully paid_.

### Monthly instalments

Customer is paying off a £6,000 invoice over six months. Six payments of £1,000\. Invoice sits at _partially paid_ for months, flips to _fully paid_ on the sixth payment.

### Short payments

Customer paid £980 against a £1,000 invoice (bank charge took £20, or just a typo). Invoice stays at _partially paid_ with £20 due, chase the difference, or write it off with a small credit memo.

## Voiding a payment

If a payment was recorded by mistake (typo, wrong invoice, or the payment turned out to bounce) you can **void** it.

Open the invoice → **Payments** tab → click the payment → **Void**.

What happens:

* The payment's amount is removed from the _amount paid_ total.
* The invoice's status updates back (e.g. from _fully paid_ to _partially paid_).
* Your books get a **reversing entry**: the original journal entry is undone with an equal-and-opposite one, see [Accounting](https://flexie.io/resources/finance/accounting). Nothing is deleted; voiding leaves a clean audit trail.

> Voiding can't be undone with another click. If you change your mind after voiding, record the payment again.

## What a payment looks like to your accountant

A payment isn't just a number against an invoice, it's also a journal entry in your books. Recording a payment of £400 against an unpaid invoice does this:

|            | Account             | Amount | Note               |
| ---------- | ------------------- | ------ | ------------------ |
| **Debit**  | Cash (or Bank)      | £400   | money in           |
| **Credit** | Accounts Receivable | £400   | customer owes less |

A voided payment does the opposite, reversing both entries. The ledger remains balanced at every step.

See [Accounting](https://flexie.io/resources/finance/accounting) for the full picture, including how partial payments interact with the tax-payable account.

## Payments from automations

Workflows can record payments too, useful when a payment gateway sends you a webhook confirming a card charge. Use the **Record payment** action in your workflow with the amount, method, and reference fields filled in from the webhook data.

See [Workflow automation](https://flexie.io/resources/workflows/overview) for the broader picture.

## Refunds and over-payments

Flexie's payment system is for money **in**. For money **out**:

* **Refund a customer who paid too much**: issue a credit memo against their invoice (see [Invoices → Credit memos](https://flexie.io/resources/finance/invoices#credit-memos-refunds-and-returns)) and process the refund through your bank or card processor separately.
* **Apply an over-payment to the next invoice**: record the actual amount paid against the open invoice (up to the balance), then apply the excess to the next invoice when you raise it. Most teams find it cleaner to issue a credit memo and re-bill the net amount.

## Gotchas

* **A payment is tied to one invoice.** If a customer sends one cheque covering three invoices, record three payments, one per invoice, with the same date and reference. Don't try to attach a single payment to multiple invoices.
* **The payment date matters for your books.** Money received on 31 December lands in this year's revenue (or cash-account movement); money received on 1 January doesn't. The payment date, not the date you recorded it, is what counts.
* **Drafts can't take payments.** A draft invoice has no payment tab, finalise it first.
* **You can record a payment dated in the past.** Useful when reconciling against a bank statement that lists payments from earlier in the week. Don't, however, post-date payments to the future unless you know what you're doing, they affect the payment status immediately.
* **Voiding a payment doesn't notify the customer.** If the customer thinks the invoice is paid (they got a thank-you email) and you've since voided the payment, you'll need to reach out to them separately.

## Next

* [Accounting](https://flexie.io/resources/finance/accounting): what every payment does to your books, and how the chart of accounts is organised.
* [Invoices](https://flexie.io/resources/finance/invoices): the bills payments settle.
* [Workflow automation](https://flexie.io/resources/workflows/overview): triggers when a payment is recorded or an invoice is fully paid.

---

## Products

Source: https://flexie.io/resources/finance/products

# Products

Last updated 26 May 2026

![A Flexie product form, with name, price, unit of measure, and the tax that should apply](https://flexie.io/image/resources/finance-products.png)

Everything you sell, whether a physical product with stock or a service billed by the hour, the day, or the job. Products are the building blocks every quote and every invoice is made of.

## Two kinds of product

| Kind                 | What it is                                                                                       | Examples                                                             |
| -------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
| **Physical product** | An item you keep stock of. Flexie tracks how many you've got and how many are available to sell. | A laptop, a bag of coffee, a printer cartridge.                      |
| **Service**          | Something you do for a price. No stock, you can sell as many as your team can deliver.           | A consultation, an hour of training, a fixed-price installation job. |

Both kinds share the same fields. The only difference is whether Flexie tracks stock for it.

## Creating a product

Click **New** on the products list.

### The basics

| Field               | What it does                                                                                                               |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| **Name**            | The product's display name, shown on quotes and invoices.                                                                  |
| **Description**     | Detailed description; appears on the customer-facing documents.                                                            |
| **Type**            | _Inventory_ (physical product with stock) or _Service_. Pick this carefully; it controls the rest of the form.             |
| **SKU**             | Stock-keeping unit. Optional, but useful for matching against barcodes or imports.                                         |
| **Category**        | Group products under categories (Hardware, Consulting, Subscription).                                                      |
| **Unit of measure** | What you sell in: _each / piece_, _hour_, _day_, _kg_, _litre_, _box_, anything you need. Used on quote and invoice lines. |
| **Price**           | The standard selling price. Customers and quotes can override it.                                                          |
| **Cost**            | What it costs _you_ (cost of goods sold). Used for margin reporting and accounting.                                        |

### Tax

| Field               | What it does                                                                                                                                                         |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Sales tax**       | Which tax to apply when this product appears on a quote or invoice. Pick from your [tax library](https://flexie.io/resources/finance/taxes), or leave blank for a tax-exempt product. |
| **Tax calculation** | _Tax-inclusive_ or _Tax-exclusive_, see below.                                                                                                                       |

#### Tax-inclusive vs. tax-exclusive

This is a choice you make per product:

* **Tax-exclusive**: the **Price** field is the price _before_ tax. Tax gets added at line time. This is what most B2B businesses prefer: list price plus tax.
* **Tax-inclusive**: the **Price** field is the price _with_ tax already baked in. The line still shows the tax separately, but the price you display to the customer doesn't change. Common in B2C / retail settings where shoppers expect "the price is the price."

Use whichever matches how you display prices to your customers. The total on the invoice is the same either way; the difference is just which number you wrote down as the _Price_.

### Inventory (physical products only)

| Field                  | What it does                                                                                                                     |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| **Needs fulfilment**   | Yes / No, does this product need to be shipped or delivered? When _Yes_, the product flows into your fulfilment / picking lists. |
| **Quantity on hand**   | How many you currently have in stock.                                                                                            |
| **Quantity available** | How many are free to sell (on-hand minus anything reserved).                                                                     |
| **As-of date**         | The date the stock count was last set or adjusted.                                                                               |

For services, these inventory fields aren't shown.

### Accounting

| Field                       | What it does                                                                                                |
| --------------------------- | ----------------------------------------------------------------------------------------------------------- |
| **Revenue account**         | Where revenue from this product lands in your chart of accounts (e.g. _Service Revenue_, _Hardware Sales_). |
| **Expense account**         | Where the cost of goods sold for this product is recorded.                                                  |
| **Inventory asset account** | (Physical products only) Where this product's stock value sits on the balance sheet.                        |

If you leave these blank, sales of this product land in your default revenue account, see [Accounting](https://flexie.io/resources/finance/accounting). Most accounts configure these once per product _category_ rather than per product.

## How a product appears on a quote or invoice

When you add a product to a quote or invoice line, Flexie pre-fills the line from the product:

* The line's **description** comes from the product's name + the product description (you can override per-line).
* The line's **unit price** comes from the product's price (override per-line for one-off discounts).
* The line's **tax** comes from the product's sales tax.
* The line's **unit** comes from the product's unit of measure.

You can then adjust **quantity**, apply a **line-level discount** (a percentage or a fixed amount), and Flexie computes the line total.

## Down payment products

Flexie has one special product type, a **Down Payment** product, that's used behind the scenes by the [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash) flow when you bill a deposit. You typically configure one of these during account setup; you don't add it to quotes by hand.

If you don't see a down-payment line on the new-invoice form when billing a deposit from a quote, ask your administrator to set up the Down Payment product.

## Categories

Group your products with **Categories**: _Hardware_, _Software_, _Consulting_, _Recurring fees_, and so on. Categories also give you a convenient place to set the default revenue / expense / inventory accounts so you don't have to do it on every product.

Manage categories from the **Categories** screen, or inline when creating a product.

## Pricing tips

* **Set a sensible default price.** It pre-fills the line. Use per-line overrides for negotiated deals, that way the product's list price stays clean.
* **Cost matters even when you're not strictly accounting.** Setting a realistic cost is what makes margin reports useful.
* **Tax-inclusive prices.** If you sell to consumers in a region where prices are displayed VAT-inclusive (most of Europe, for example), set those products to _Tax-inclusive_. Otherwise the customer sees one price online and another on the invoice.
* **Service products with a "per hour" unit** are perfect for time tracking, the line shows _4 hours × £80 = £320_ and reads naturally on the invoice.

## Gotchas

* **Changing a product's price doesn't change existing quotes or invoices.** Once it's on a line, the price is captured on the line. Updating the product affects only _new_ lines added from that point on.
* **Changing a product's tax doesn't change existing lines either**, same reason. Re-add the product to a quote or invoice if you want the new tax to apply.
* **Stock changes don't happen automatically on sale.** The current build doesn't decrement _quantity on hand_ when you finalise an invoice. That's intentional, since not every business wants to treat invoice = stock movement. Use the inventory adjustment screen to record stock movements explicitly.
* **Categories aren't auto-applied.** Setting a default revenue account on a category doesn't retroactively update existing products. It's the default for the _next_ product you create in that category.

## Next

* [Taxes](https://flexie.io/resources/finance/taxes): the tax rates you'll attach to your products.
* [Quotes](https://flexie.io/resources/finance/quotes): using products on a proposal.
* [Invoices](https://flexie.io/resources/finance/invoices): using products on a bill.

---

## Quotes

Source: https://flexie.io/resources/finance/quotes

# Quotes

Last updated 26 May 2026

![A Flexie quote with line items, taxes, and totals, ready to send to a customer](https://flexie.io/image/resources/finance-quotes.png)

A price offer to your customer, before any money changes hands. Build it from products and services, send it as a PDF, and when the customer agrees, turn it into an invoice.

## What a quote is

A **quote** is a structured offer you make a customer. It lists the things you'll do or sell, what they cost, what taxes apply, and how long the price is good for. It's a working document: you can revise it, share new versions, and negotiate, until the customer agrees.

A quote is _not_ financial yet. It doesn't appear in your revenue, it doesn't create any accounting entries. Only when you turn it into an invoice does the money side begin.

## Creating a quote

Click **New** on the quotes list.

### The header

| Field                      | What it does                                                                                                          |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| **Title**                  | A short name for the quote (shown internally and at the top of the PDF).                                              |
| **Customer name**          | The person or company the quote is for.                                                                               |
| **Customer (record link)** | Link to the contact, lead, or account this customer corresponds to in Flexie, so the quote appears on their timeline. |
| **Deal**                   | Optional, link the quote to a sales deal.                                                                             |
| **Owner**                  | The user who owns this quote in Flexie (defaults to you).                                                             |

### Addresses

Two address blocks, **Billing** and **Shipping**:

* Street, city, postcode/ZIP, region/state, country.
* The billing address appears on the PDF; the shipping address is for delivery (useful when they differ).

If the addresses are the same, fill in the billing block and skip shipping (or copy across with one click).

### Currency

| Field             | What it does                                                                                              |
| ----------------- | --------------------------------------------------------------------------------------------------------- |
| **Currency**      | The currency the quote is in, _USD_, _EUR_, _GBP_, any standard currency code.                            |
| **Exchange rate** | If the quote is in a foreign currency, the rate to your account's base currency at the time of the quote. |

### Validity

| Field               | What it does                                                                                                 |
| ------------------- | ------------------------------------------------------------------------------------------------------------ |
| **Expiration date** | When the price stops being guaranteed. After this date, the quote shows as _expired_ on the customer's view. |
| **Terms**           | Your terms and conditions: pricing notes, payment terms, anything else. Appears at the bottom of the PDF.    |
| **Internal note**   | Notes only your team sees, never goes on the PDF.                                                            |

## Line items

The heart of the quote. Each line is a product or service from your [products library](https://flexie.io/resources/finance/products).

### Adding a line

For each line:

| Field           | What it does                                                                                            |
| --------------- | ------------------------------------------------------------------------------------------------------- |
| **Product**     | Pick from your products list. The line auto-fills from the product: description, unit price, unit, tax. |
| **Description** | The description that appears on the PDF. Pre-filled from the product; override per-line for one-offs.   |
| **Quantity**    | How many. The unit (each, hour, day) comes from the product.                                            |
| **Unit price**  | The price per unit. Pre-filled from the product; override for negotiated deals.                         |
| **Discount**    | A line-level discount, _percentage_ (e.g. 10%) or _fixed amount_ (e.g. £50 off this line).              |
| **Tax**         | Which tax applies. Pre-filled from the product; you can change it per line.                             |

The line total recomputes as you type. Flexie shows you both the **subtotal** (the maths before tax) and the **line total** (subtotal minus discount, then add or include tax depending on the product's tax-calculation setting, see [Products → Tax](https://flexie.io/resources/finance/products#tax)).

### Reordering and removing lines

Drag the handle on the left of each line to reorder. The little _x_ button at the end removes the line.

### Quote-wide discount

Below the line items, an optional **quote-level discount** applies on top of the subtotal, also as a percentage or fixed amount. Use this for "round it down to a nice number" deals or end-of-quarter incentives.

## The totals block

At the bottom of the quote you'll see:

|           | Amount        |
| --------- | ------------- |
| Subtotal  | £1,234.56     |
| Discount  | −£50.00       |
| Tax       | £236.91       |
| **Total** | **£1,421.47** |

When **all** lines use tax-inclusive pricing, the layout shifts slightly to show _Total including tax_ with the tax broken out below, still adding up to the same total.

## Quote status

A quote moves through a small set of statuses:

| Status        | Meaning                                                                                                    |
| ------------- | ---------------------------------------------------------------------------------------------------------- |
| **Draft**     | Being worked on. Not sent to the customer yet.                                                             |
| **Sent**      | Delivered to the customer (email, SMS, WhatsApp, PDF download).                                            |
| **Won**       | The customer has agreed, but no invoice has been raised yet.                                               |
| **Invoiced**  | One or more invoices have been raised against this quote. Once _invoiced_, the quote is locked from edits. |
| **Cancelled** | The deal didn't close, or the quote was withdrawn.                                                         |

You can move a quote between _Draft_ and _Sent_ freely. Once it's been _invoiced_ (even partially), the quote is read-only, see [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash).

## Versions

Sometimes a quote goes through several revisions before the customer agrees ("can you take that line out and add this one?"). Each save creates a **version**. The quote keeps a version number so you can see how many revisions it's been through, and the PDF shows the version of the quote at the moment of send.

## Sending the quote

You can deliver a quote three ways:

* **Download PDF**, for printing or handing over in person.
* **Email**, directly from the quote, with the PDF attached. You can pick a template (e.g. _"Quote, first send"_, _"Quote, revised"_), see [Templates](https://flexie.io/resources/inbox/templates).
* **SMS or WhatsApp**, a short message with a link to the quote's PDF.

After sending, the quote's status flips to **Sent**.

## What the customer sees

The PDF is a branded document showing:

* Your company name, logo, contact details (from your account settings).
* The customer's name and address.
* The quote number, date, and expiration date.
* The line items with quantities, unit prices, discounts, and taxes.
* The totals block.
* Your terms and conditions.

Layouts come from **quote templates**, your administrator can edit the HTML / CSS to match your branding.

## Acceptance

When the customer says yes, you move the quote forward, see [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash) for the full flow.

In short:

1. Open the quote.
2. Click **Convert to Invoice** (or **Convert to Cash**, depending on the build).
3. Pick how you want to invoice it, _full_, _percentage_, _fixed amount_, see the deep-dive.
4. Flexie creates the invoice(s) and updates the quote's status.

If the customer declines, change the quote's status to _Cancelled_.

## Gotchas

* **A line's price is captured the moment you add it.** Changing the product's master price later doesn't change quotes that already use it. Useful, your historical quotes stay accurate.
* **Don't edit a quote that's already been invoiced.** Flexie locks it for you, but if you absolutely need to revise (say, the customer changed their mind) create a fresh quote. The invoiced amount on the old quote stays on the books.
* **Expiration dates are advisory.** A quote past its expiration date still works; it just shows the customer that the offer has expired. Renew by changing the expiration date and re-sending.
* **Foreign-currency quotes** record the exchange rate at the moment the quote was made. The exchange rate at _invoice_ time is what ends up in your books, they can differ; Flexie shows you both.

## Next

* [Invoices](https://flexie.io/resources/finance/invoices): what the quote becomes when the customer agrees.
* [Convert to Cash](https://flexie.io/resources/finance/convert-to-cash): the smart bridge from quote to invoice, including down payments and partial invoicing.

---

## Taxes

Source: https://flexie.io/resources/finance/taxes

# Taxes

Last updated 26 May 2026

![A Flexie tax form, rate, type, class, and the chart-of-accounts mapping](https://flexie.io/image/resources/finance-taxes.png)

Define each tax rate once, attach it to the products it applies to, and Flexie does the maths everywhere: quotes, invoices, accounting.

## What a tax is

A **tax** is a named rate (with a rate type) plus a few labels that help you keep your books straight. You set it up once, then attach it to the products that should charge it.

Examples:

* **VAT 20%**, the standard UK VAT rate.
* **Sales Tax (CA) 7.25%**, California sales tax.
* **GST 5%**, Canadian goods and services tax.
* **Reverse-charge VAT**, a 0% rate used for B2B EU exports.

You can have as many taxes as you need.

## Creating a tax

Click **New** on the taxes list.

| Field           | What it does                                                                                                                            |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**        | Display name, what appears on quotes and invoices (e.g. _"VAT 20%"_).                                                                   |
| **Rate type**   | _Percentage_ (typical, e.g. 20%) or _Fixed_ (a flat amount per line, e.g. an environmental levy of £5).                                 |
| **Rate**        | The actual rate, 20 for 20%, or the flat amount for a fixed-rate tax.                                                                   |
| **Tax type**    | _Sales_ (a tax you charge customers) or _Purchase_ (a tax you pay suppliers). The two are kept separate in your books.                  |
| **Tax class**   | _Domestic_, _Export_, or _EU_. Used to keep cross-border taxes separate for reporting. Pick _Domestic_ if you only sell in one country. |
| **Tax code**    | A short identifier, useful for tax-authority reporting or matching against codes your bookkeeper uses.                                  |
| **Description** | Optional, internal notes.                                                                                                               |

### Where the money goes

| Field                    | What it does                                                                                                                   |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------ |
| **Sales tax account**    | The account in your [chart of accounts](https://flexie.io/resources/finance/accounting) where this tax's _output_ (sales tax owed) is recorded. |
| **Purchase tax account** | (For purchase taxes) Where _input_ tax (claimable) is recorded.                                                                |

If you leave these blank, Flexie uses your default tax accounts. Most accounts set these once during initial configuration.

## Tax-inclusive vs. tax-exclusive pricing

This isn't set on the tax itself, it's set on the **product** (see [Products → Tax](https://flexie.io/resources/finance/products#tax)). The same tax (e.g. _VAT 20%_) can be used by inclusive-priced products _and_ exclusive-priced products at the same time.

| Pricing style     | What you type as the product price | What appears on the line             |
| ----------------- | ---------------------------------- | ------------------------------------ |
| **Tax-exclusive** | The pre-tax price (£100)           | Subtotal £100 + tax £20 = total £120 |
| **Tax-inclusive** | The all-in price (£120)            | Subtotal £100 + tax £20 = total £120 |

Either way, the tax total is the same. The difference is just which number you wrote down as the _Price_.

## How a tax flows through

When a line item uses a product with a sales tax:

1. **On the quote / invoice line**: Flexie computes the tax amount for that line (based on the line subtotal and the tax rate, with inclusive / exclusive handling).
2. **In the totals block**: taxes are summed and shown as a line, _Subtotal £500.00 / Tax £100.00 / Total £600.00_.
3. **On invoice finalisation**: Flexie posts a journal entry that credits your **Sales tax account** for the tax amount (so you know what you owe the tax authority).
4. **When you pay the tax authority**: you record that as a payment against the Sales tax account, which clears the liability.

The first three steps happen automatically. Only the fourth needs manual recording, since paying the tax authority is a real-world event Flexie can't see.

## Common patterns

### One country, one tax

Most small businesses have a single sales tax (e.g. VAT 20%, GST 5%). Configure that one tax, set it as the default on every product, and you're done.

### Multiple rates in one country

Sales tax can differ by product type, e.g. food at 0%, books at 5%, everything else at 20%. Configure each rate as a separate tax, and attach the right one to each product (or each product _category_).

### Tax-exempt customers

Some customers (e.g. registered charities, B2B with valid EU VAT numbers) are tax-exempt. Two approaches:

* **Override per line on the invoice.** Add the line with no tax, this works for one-off cases.
* **Mark the customer as tax-exempt.** When customer-level tax-exemption is configured, lines for that customer get the tax removed automatically. Ask your administrator if you need this set up.

### Cross-border sales

If you sell to several countries:

* Use the **Tax class** field to keep _Domestic_, _Export_, and _EU_ taxes separate.
* Define separate taxes per region you sell into.
* Map each tax to its own account in the chart of accounts so your books reflect each jurisdiction cleanly.

## Compound taxes (tax on tax)

A few jurisdictions have taxes that apply on top of other taxes (e.g. a provincial tax that's calculated on the price _plus_ federal tax). Flexie supports this: when defining a tax, you can mark another tax as its parent, and the rate will compound.

This is a niche case; most teams don't need it. Don't enable it unless your bookkeeper has explicitly told you the local tax works this way.

## Gotchas

* **Once a tax is on a line, it stays on the line.** Editing the tax's rate later doesn't change quotes or invoices that already exist, they keep the rate that was applied at the time. If a rate change is retroactive (rare), you'd need to revise the affected documents.
* **Tax-exclusive is the safer default.** If you're not sure whether your customers expect tax-inclusive or tax-exclusive prices, go with exclusive, it's clearer where the tax is and reduces "wait, why did the total change?" questions.
* **Fixed-amount taxes don't scale.** A fixed £5 environmental levy gets applied as £5, regardless of the line subtotal. If you want it to scale with quantity, the line's quantity does it automatically, `2 × line with £5 levy = £10 levy`.
* **Sales vs. purchase taxes can't be mixed.** A sales tax can't appear on a purchase line and vice-versa. They land in different accounts and report differently.

## Next

* [Quotes](https://flexie.io/resources/finance/quotes): where taxes first show up on a customer-facing document.
* [Invoices](https://flexie.io/resources/finance/invoices): where taxes become real money owed.
* [Accounting](https://flexie.io/resources/finance/accounting): where the tax amounts land in your books.

---

## Flexie Scripting: Filters & Working with Lists

Source: https://flexie.io/resources/flexie-scripting/filters-and-collections

# Filters & Working with Lists

Last updated 23 May 2026

![A value flowing through chained Flexie Scripting filters, and a list being grouped and totalled](https://flexie.io/image/resources/flexie-scripting-filters-and-collections.png)

## What a filter is

A **filter** transforms a value using the pipe symbol `|`. The value on the left is fed into the filter on the right:

```
{{ "hello world" | upper }}        → HELLO WORLD
{{ 1234.5 | number_format(2) }}    → 1,234.50

```

Filters chain left to right, each one receives the result of the one before:

```
{{ first_name | trim | capitalize }}

```

## Everyday formatting filters

These are the standard filters available in Flexie Scripting:

| Filter                      | What it does                              | Example → result                             |
| --------------------------- | ----------------------------------------- | -------------------------------------------- |
| upper / lower               | Change case.                              | {{ "abc" \| upper }} → ABC                   |
| capitalize                  | Capitalise the first letter.              | {{ "john" \| capitalize }} → John            |
| title                       | Capitalise Each Word.                     | {{ "acme ltd" \| title }} → Acme Ltd         |
| trim                        | Remove surrounding spaces.                | {{ " x " \| trim }} → x                      |
| default(x)                  | Use a fallback when empty.                | {{ phone \| default("N/A") }}                |
| number\_format(d, dec, sep) | Format a number.                          | {{ 1234.5 \| number\_format(2) }} → 1,234.50 |
| round(p)                    | Round a number.                           | {{ 3.146 \| round(2) }} → 3.15               |
| abs                         | Absolute value.                           | {{ -5 \| abs }} → 5                          |
| length                      | Count items or characters.                | {{ invoices \| length }}                     |
| join(sep)                   | Join a list into text.                    | {{ \["a","b"\] \| join(", ") }} → a, b       |
| split(sep)                  | Split text into a list.                   | {{ "a,b,c" \| split(",") }}                  |
| replace({from: to})         | Replace substrings.                       | {{ s \| replace({"-": " "}) }}               |
| slice(start, len)           | Take part of a list or string.            | {{ items \| slice(0, 5) }}                   |
| first / last                | First or last item.                       | {{ invoices \| first }}                      |
| reverse                     | Reverse a list or string.                 | {{ items \| reverse }}                       |
| sort                        | Sort a list.                              | {{ names \| sort }}                          |
| keys                        | The keys of a map.                        | {{ row \| keys }}                            |
| merge(other)                | Combine two lists or maps.                | {{ a \| merge(b) }}                          |
| nl2br                       | Turn line breaks into HTML <br>.          | {{ note \| nl2br }}                          |
| striptags                   | Remove HTML tags.                         | {{ html \| striptags }}                      |
| escape                      | Make text safe for HTML.                  | {{ userText \| escape }}                     |
| raw                         | Output without escaping (use with care).  | {{ trustedHtml \| raw }}                     |
| json\_encode                | Turn data into a JSON string.             | {{ row \| json\_encode }}                    |
| url\_encode                 | Make text URL-safe.                       | {{ q \| url\_encode }}                       |
| map, filter, reduce, batch  | Transform, narrow, fold, or chunk a list. | {{ items \| filter(i => i.active) }}         |

## Flexie's own filters

On top of the standard set, Flexie adds these:

| Filter                                         | What it does                                     | Example                                         |
| ---------------------------------------------- | ------------------------------------------------ | ----------------------------------------------- |
| cast\_int                                      | Force a value to a whole number (strips commas). | {{ "1,234" \| cast\_int }} → 1234               |
| cast\_float(precision=0)                       | Force a value to a decimal number.               | {{ "12.5" \| cast\_float(2) }}                  |
| cast\_string                                   | Force a value to text.                           | {{ 123 \| cast\_string }}                       |
| cast\_bool                                     | Force a value to true or false.                  | {{ "1" \| cast\_bool }}                         |
| slugify(sep="-")                               | Make a URL-safe slug.                            | {{ "Hello World!" \| slugify }} → hello-world   |
| json\_decode                                   | Parse a JSON string into data.                   | {{ body \| json\_decode }}                      |
| json\_path(expr)                               | Extract a nested value by path.                  | {{ data \| json\_path("$.total") }}             |
| regex\_replace(pattern, replacement, limit=-1) | Pattern-based find and replace.                  | {{ s \| regex\_replace("/\\\\s+/", " ") }}      |
| group\_by(key)                                 | Group a list of records by a field.              | {{ deals \| group\_by("stage") }}               |
| unique\_by(key)                                | Drop duplicates by a field.                      | {{ contacts \| unique\_by("email") }}           |
| sum\_by(key, scale=4)                          | Total a numeric field across records.            | {{ items \| sum\_by("amount") }}                |
| sort\_by(key, dir="ASC")                       | Sort records by a field.                         | {{ invoices \| sort\_by("due\_date", "DESC") }} |

## Working across a list of records

You will often fetch many records (with `findMany`, `getSmartListRecords`, `findDeals`, etc.) and then summarise or reshape them. These helpers do that.

### Totals and statistics

| Function                   | What it does                           |
| -------------------------- | -------------------------------------- |
| sumField(list, field)      | Add up one field across a list.        |
| avgField(list, field)      | Average one field across a list.       |
| minField(list, key)        | Smallest value of a field.             |
| maxField(list, key)        | Largest value of a field.              |
| countDistinct(list, field) | How many different values a field has. |

```
{% set invoices = findMany("invoice", "contact_id", id) %}
Total billed: {{ sumField(invoices, "total_incl_tax") | number_format(2) }}
Largest: {{ maxField(invoices, "total_incl_tax") | number_format(2) }}

```

### Reshaping a list

| Function                                     | What it does                                                                                           |
| -------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| collectionColumn(list, column, indexBy=null) | Pull a single column out as a flat list, or, with indexBy, build a lookup map keyed by another column. |

```
{# A flat list of every email on the account #}
{{ collectionColumn(getAccountContacts(id), "email") | join(", ") }}

```

## Looping with grouping, a worked example

Show invoices grouped by status, with a subtotal per group:

```
{% set invoices = findMany("invoice", "contact_id", id) %}
{% set grouped = invoices | group_by("status") %}

{% for status, rows in grouped %}
  {{ status | upper }} ({{ rows | length }})
  {% for inv in rows | sort_by("due_date") %}
    - {{ inv.number }}: {{ inv.total_incl_tax | number_format(2) }}
  {% endfor %}
  Subtotal: {{ rows | sum_by("total_incl_tax") | number_format(2) }}

{% endfor %}

```

## Reusable blocks, snippets

If you keep retyping the same chunk of content (a header, a signature, a styled footer), an administrator can save it as a **snippet** and you include it by name:

```
{% snippet "email_header" %}
... your content ...
{% snippet "email_footer" %}

```

A snippet is itself Flexie Scripting, so it can contain its own logic and tokens and will see the same record data as the template that includes it.

## Next steps

* [Recipes](https://flexie.io/resources/flexie-scripting/recipes): these pieces assembled into complete solutions.
* [Where it runs & its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits): what data is available in each context, and the safety boundaries.

---

## Flexie Scripting: Function Reference

Source: https://flexie.io/resources/flexie-scripting/function-reference

# Function Reference

Last updated 23 May 2026

![The Flexie Scripting function catalogue, grouped by purpose, with examples](https://flexie.io/image/resources/flexie-scripting-function-reference.png)

Functions are called by name with parentheses: `{{ functionName(arg1, arg2) }}`. Arguments shown with `= value` are optional and have that default.

## 1\. Looking up records

These functions read data from across your Flexie account, so a template can show related information, a contact's invoices, an account's contacts, totals, counts.

| Function                                                          | What it does                                                                                                                    | Example                                                                                |
| ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| findOne(type, field, value, …)                                    | Fetch a **single** record matching all the field/value pairs you give (joined with AND). Returns an empty result if none found. | {{ findOne("lead", "email", "john@example.com") }}                                     |
| findMany(type, field, value, orderBy='id', dir='ASC', limit=1000) | Fetch **many** records matching one field, optionally sorted and capped.                                                        | {{ findMany("invoice", "status", "finalized", "date\_added", "DESC", 50) }}            |
| findCount(type, field, value, …)                                  | Count records matching all field/value pairs.                                                                                   | {{ findCount("deal", "stage\_id", 5, "owner\_id", 3) }}                                |
| findSum(type, column, field, value, …)                            | Add up a numeric column across matching records.                                                                                | {{ findSum("invoice", "total\_incl\_tax", "contact\_id", 42, "status", "finalized") }} |
| findMin(type, column, field, value, …)                            | Smallest value of a column across matching records.                                                                             | {{ findMin("deal", "amount", "stage\_id", 5) }}                                        |
| findMax(type, column, field, value, …)                            | Largest value of a column across matching records.                                                                              | {{ findMax("deal", "amount", "is\_won", 1) }}                                          |
| findByPhoneNumber(type, phoneField, number)                       | Find a record by a phone number held in a specific field.                                                                       | {{ findByPhoneNumber("contact", "phone", "+155501234") }}                              |
| getSmartListRecords(type, listAlias)                              | All records belonging to a saved smart list.                                                                                    | {{ getSmartListRecords("lead", "high\_value") }}                                       |
| getOrganization(idOrVat)                                          | Look up an organisation by its id or VAT number.                                                                                | {{ getOrganization("DE123456789") }}                                                   |
| getUserById(userId)                                               | Fetch a user (name, email, phone, profile image, etc.).                                                                         | {{ getUserById(5).full\_name }}                                                        |
| getAccountContacts(accountId)                                     | All contacts linked to an account.                                                                                              | {{ getAccountContacts(42) }}                                                           |
| findDeals(type, entityId)                                         | All deals linked to a contact, account, or lead.                                                                                | {{ findDeals("contact", 42) }}                                                         |
| findCases(type, entityId)                                         | All cases linked to a record.                                                                                                   | {{ findCases("account", 10) }}                                                         |
| findDealsValue(type, stage='\*', pipeline='\*', entityId)         | Total deal value for a record, optionally filtered by stage (pending/won/lost/\*) and pipeline.                                 | {{ findDealsValue("contact", "won", "\*", 42) }}                                       |

> **Result limits.** Look-ups that can return many rows are capped at 1,000 results to keep templates fast. Filter tightly and sort, rather than pulling everything.

### Ready-made statistics

These return a small bundle of figures in one call, handy for customer summaries.

| Function                        | Returns                                                                                     |
| ------------------------------- | ------------------------------------------------------------------------------------------- |
| getDealStats(type, entityId)    | total, active, won, lost                                                                    |
| getInvoiceStats(type, entityId) | invoice\_total, credit\_memo\_total, draft, sent, canceled, won, finalized, pending, active |
| getCaseStats(type, entityId)    | total, open, pending, solved, closed                                                        |

In an account-context template, the account's own `id` is read at the top level:

```
This account has {{ getDealStats("account", id).won }} won deals
worth {{ findDealsValue("account", "won", "*", id) | number_format(2) }}.

```

### Advanced: direct queries

For administrators and power users who need data the helpers above do not cover:

| Function   | What it does                                                                                                                                                                                                                                               |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| query(sql) | Run a **read-only** data query and get the rows back. Only retrieval is allowed (SELECT and WITH only, no INSERT, UPDATE, DELETE, DROP, and no SELECT \*). Results are capped at 1,000 rows. Returns the rows, or {"error": "…"} if the query is rejected. |

```
{% set rows = query("SELECT id, email FROM leads WHERE status = 1 LIMIT 10") %}
Matching leads: {{ rows | length }}

```

## 2\. Numbers and maths

| Function                                                                        | What it does                                                                                                                      | Example → result                                                  |
| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| add(a, b, …)                                                                    | Add all arguments.                                                                                                                | {{ add(10, 5, 3) }} → 18                                          |
| subtract(a, b)                                                                  | a minus b.                                                                                                                        | {{ subtract(100, 30) }} → 70                                      |
| multiply(a, b, …)                                                               | Multiply all arguments.                                                                                                           | {{ multiply(5, 4, 2) }} → 40                                      |
| divide(a, b)                                                                    | a divided by b (empty if dividing by zero).                                                                                       | {{ divide(100, 4) }} → 25                                         |
| round(n, places=0, mode="ROUND\_HALF\_UP")                                      | Round to a number of decimal places.                                                                                              | {{ round(3.14159, 2) }} → 3.14                                    |
| squareRoot(n)                                                                   | Square root.                                                                                                                      | {{ squareRoot(16) }} → 4                                          |
| cubeRoot(n)                                                                     | Cube root.                                                                                                                        | {{ cubeRoot(27) }} → 3                                            |
| max(a, b, …)                                                                    | Largest of the given values (also works on a list).                                                                               | {{ max(1, 3, 2) }} → 3                                            |
| min(a, b, …)                                                                    | Smallest of the given values (also works on a list).                                                                              | {{ min(1, 3, 2) }} → 1                                            |
| random(…)                                                                       | A random value: random() (a number), random(5) (0 to 5), random(\["a","b"\]) (a random item), random("ABC") (a random character). | {{ random(\["a","b","c"\]) }}                                     |
| range(from, to, step=1)                                                         | A sequence of numbers, handy in a loop.                                                                                           | {% for i in range(1, 5) %}…{% endfor %}                           |
| numberFormat(n, decimals=0, style="none", round="ROUND\_HALF\_EVEN")            | Format with grouping. style is ",\|." (1,234.56), ".|," (1.234,56), or none.                                                      | {{ numberFormat(1234.5678, 2, ",\|.") }} → 1,234.57               |
| reverseFormattedNumber(text, style=",\|.")                                      | Turn a formatted string back into a number you can calculate with.                                                                | {{ reverseFormattedNumber("1.234,56", ".\|,") }} → 1234.56        |
| formatCurrency(amount, symbol="$", decimals=2, style=",\|.", position="before") | Format a money amount with a currency symbol.                                                                                     | {{ formatCurrency(1234.5, "€", 2, ".\|,", "after") }} → 1.234,50€ |

> **Why `reverseFormattedNumber` matters.** Once a number has thousands separators it is text, not a number, `"1,200" + 50` will not behave. Reverse it first, do the maths, then format the result.

For totals **across a list** of records (`sumField`, `avgField`, `minField`, `maxField`) see [Filters & collections](https://flexie.io/resources/flexie-scripting/filters-and-collections).

## 3\. Dates and time

| Function                                                    | What it does                                                                    | Example                                |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------- | -------------------------------------- |
| now(format="Y-m-d H:i:s", tz="UTC")                         | The current date and time.                                                      | {{ now("Y-m-d") }}                     |
| date(value, format="Y-m-d H:i:s", toTz="UTC", fromTz="UTC") | Reformat a date and optionally convert its timezone.                            | {{ date(date\_added, "M j, Y") }}      |
| dateAdd(date, amount, unit="days", format="Y-m-d H:i:s")    | Add time to a date. Units: years, months, weeks, days, hours, minutes, seconds. | {{ dateAdd(due\_date, 30, "days") }}   |
| dateSubtract(date, amount, unit="days", format=…)           | Subtract time from a date.                                                      | {{ dateSubtract(now(), 1, "months") }} |
| dateDiff(date1, date2, unit="days")                         | Signed difference between two dates.                                            | {{ dateDiff(date\_added, now()) }}     |
| daysBetween(date1, date2)                                   | Whole days between two dates (always positive).                                 | {{ daysBetween(due\_date, now()) }}    |

**Format codes** are the common date pieces: `Y` 4-digit year, `m` month number, `d` day, `H` hour (24h), `i` minutes, `s` seconds, `M` short month name, `j` day without leading zero, `l` weekday name. Example: `"l, j M Y"` → `Tuesday, 3 Jun 2025`.

```
{# Current record = the invoice #}
{% if daysBetween(due_date, now()) > 0 and status != "paid" %}
  This invoice is {{ daysBetween(due_date, now()) }} days overdue.
{% endif %}

```

## 4\. Working with text

| Function                                        | What it does                                                                   | Example → result                                            |
| ----------------------------------------------- | ------------------------------------------------------------------------------ | ----------------------------------------------------------- |
| truncate(text, length=100, suffix="…")          | Shorten text, adding a suffix.                                                 | {{ truncate(subject, 30) }}                                 |
| padString(value, length, char=" ", side="left") | Pad to a fixed width.                                                          | {{ padString(42, 6, "0") }} → 000042                        |
| startsWith(text, prefix)                        | True if text begins with the prefix.                                           | {{ startsWith(phone, "+44") }}                              |
| endsWith(text, suffix)                          | True if text ends with the suffix.                                             | {{ endsWith(file, ".pdf") }}                                |
| wordCount(text)                                 | Number of words.                                                               | {{ wordCount(note.body) }}                                  |
| toAlphanumeric(text)                            | Strip everything except letters and numbers.                                   | {{ toAlphanumeric("AB-12/3") }} → AB123                     |
| htmlToText(html)                                | Convert HTML into clean plain text (great for turning an email body into SMS). | {{ htmlToText(email.html) }}                                |
| findAndReplace(html, start, end, replacement)   | Replace whatever sits between two markers.                                     | {{ findAndReplace(body, "<!--A-->", "<!--B-->", newPart) }} |
| urlEncode(text)                                 | Make text safe to drop into a URL.                                             | {{ urlEncode(email) }}                                      |
| md5(text)                                       | An MD5 fingerprint of the text.                                                | {{ md5(email) }}                                            |
| base64encode(text) / base64decode(text)         | Encode or decode text in base64.                                               | {{ base64encode(payload) }}                                 |

For pattern-based find-and-replace and slug-making, see the `regex_replace` and `slugify` filters in [Filters & collections](https://flexie.io/resources/flexie-scripting/filters-and-collections).

### Pulling things out of text

| Function                  | What it does                                      |
| ------------------------- | ------------------------------------------------- |
| verifyEmail(text)         | 1 if it looks like a valid email address, else 0. |
| extractEmails(text)       | All email addresses found in a block of text.     |
| extractPhoneNumbers(text) | All phone numbers found in text.                  |
| extractWebsiteLinks(text) | All web links found in text.                      |

```
{% set found = extractEmails(email.text) %}
{% if found | length > 0 %}Reply-to candidate: {{ found[0] }}{% endif %}

```

## 5\. Tags

Flexie stores tags as a single pipe-separated string (`vip|renewal`). These helpers make working with them safe.

| Function                   | What it does                              | Example → result                                    |
| -------------------------- | ----------------------------------------- | --------------------------------------------------- |
| addTag(tags, newTag)       | Append a tag.                             | {{ addTag("red\|blue", "green") }} → red|blue|green |
| removeTag(tags, tag)       | Remove a tag (case-insensitive).          | {{ removeTag("red\|blue", "BLUE") }} → red          |
| matchAnyTag(tagsA, tagsB)  | 1 if the two sets share at least one tag. | {{ matchAnyTag(tags, "vip\|gold") }}                |
| matchAllTags(tagsA, tagsB) | 1 if the two sets are identical.          | {{ matchAllTags(tags, "vip\|gold") }}               |

## 6\. JSON and structured data

When a value holds JSON (for example data received from another system), these turn it into something you can read.

| Function                           | What it does                                                      |
| ---------------------------------- | ----------------------------------------------------------------- |
| jsonDecode(text, associative=true) | Turn a JSON string into data you can read with dots or brackets.  |
| jsonPath(data, expression)         | Pull a nested value out using a path like $.order.items\[0\].sku. |
| isCollection(value)                | True if the value is a list or array.                             |

```
{% set order = jsonDecode(__data.webhook_body) %}
First item: {{ jsonPath(order, "$.items[0].name") }}

```

There is also a `json_decode` and `json_path` **filter** form, see [Filters & collections](https://flexie.io/resources/flexie-scripting/filters-and-collections).

## 7\. Unique values and sequence numbers

| Function                                                           | What it does                                                                                                                                   |
| ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| uuid()                                                             | A random globally-unique identifier.                                                                                                           |
| uniqueId()                                                         | A shorter unique id.                                                                                                                           |
| incrementAndGetSequenceNumber(type, field, matchField, matchValue) | Safely bump a counter column by one and return the new value, the reliable way to generate gap-free invoice or order numbers, even under load. |

```
Invoice no. {{ incrementAndGetSequenceNumber("invoice", "sequence_no", "year", "2026") }}

```

## 8\. Links, attachments, and QR codes

| Function                                                                  | What it does                                                       |
| ------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| getAttachments(type, id, name="\*", firstOnly=false)                      | Attachment details for a record (optionally filtered by filename). |
| getAttachmentsPath(type, id, name="\*", firstOnly=true)                   | Direct download URLs for attachments.                              |
| addAttachments(type, id, name="\*", …)                                    | Ready-made HTML links to attachments.                              |
| getFormAttachments(payload)                                               | Attachments from a form submission.                                |
| publicAttachmentLink(type, id, userId=null)                               | A secure public link to an attachment that needs no login.         |
| qrCode(text, border=0, width=140, height=140, bg="#FFFFFF", fg="#333333") | A QR code image (SVG) for any text or URL.                         |

```
Scan to pay: {{ qrCode("https://pay.example.com/invoice/" ~ id, 2, 200, 200) }}

```

## 9\. Security helpers (advanced)

For building authenticated links and signed payloads when integrating with other systems. These are administrator-level tools.

| Function                                                        | What it does                                            |
| --------------------------------------------------------------- | ------------------------------------------------------- |
| encrypt(text) / decrypt(text)                                   | Encrypt or decrypt with your account's secret key.      |
| signUrl(url, expiryHours)                                       | Produce a tamper-proof, time-limited link.              |
| hashHmac(algorithm, data, secret)                               | An HMAC signature (e.g. sha256) for verifying payloads. |
| jwtEncode(payload, key, alg="HS256") / jwtDecode(token, secret) | Build or read a JSON Web Token.                         |

## 10\. Utility

| Function                   | What it does                                                                                                     |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| coalesce(a, b, c, …)       | The first value that is not empty, a clean way to provide fallbacks.                                             |
| contains(haystack, needle) | True if text contains a substring, or a list contains a value.                                                   |
| getQueryString(name)       | Read a value from the current URL's query string.                                                                |
| memoryGet(key)             | Read a value from short-lived shared memory (set elsewhere by a workflow's "Memory Set" action). Read-only here. |
| getAiChatHistory(key="")   | Retrieve stored AI conversation history.                                                                         |
| dump(value)                | Print a value's full contents, for **debugging** a template only.                                                |

```
Hello {{ coalesce(first_name, "there") }}!

```

> Some specialised functions also exist for fiscal or regulatory document signing and for streaming external data files. These are configured by administrators for specific integrations and are outside everyday use.

## Next steps

* [Filters & collections](https://flexie.io/resources/flexie-scripting/filters-and-collections): transforming values with `| filters` and working across lists of records.
* [Recipes](https://flexie.io/resources/flexie-scripting/recipes): these functions combined into real solutions.

---

## Flexie Scripting: Language Basics

Source: https://flexie.io/resources/flexie-scripting/language-basics

# Language Basics

Last updated 23 May 2026

![A short Flexie Scripting template with placeholders, an if block, and a for loop](https://flexie.io/image/resources/flexie-scripting-language-basics.png)

Flexie Scripting is small on purpose: values, record fields, conditions, loops, and operators. Once you know that handful of shapes, you can read or write any script you'll encounter in templates, workflow actions, and dynamic endpoints.

## Printing a value

Use `{{ ... }}` to print something:

```
{{ "Hello" }}            → Hello
{{ 42 }}                 → 42
{{ first_name }}         → the first_name of the current record

```

Anything between the braces is worked out first, then printed. You can combine text and values by stringing pieces together, but the usual way is to write plain text and only drop into `{{ }}` where a value belongs:

```
Dear {{ first_name }} {{ last_name }},

```

## Reading record fields

When a script runs, it is given the **record it is working on**, a contact, a deal, an invoice, and so on. You read that record's fields **directly, with no prefix**:

```
{{ first_name }}
{{ email }}
{{ total_incl_tax }}
{{ stage }}

```

The name in the braces is the field's **alias** (its system name), which you can find next to the field itself in the admin field setup (Custom Fields).

> There is **no** built-in `contact.`, `deal.`, or `invoice.` global. Writing `{{ contact.first_name }}` does **not** work, the current record's fields live at the top level. A prefixed path like `{{ X.field }}` is only valid when `X` is a name you have created yourself (see below).

### Variables for any **other** record

To work with a record that is **not** the current one, fetch it with a look-up function (such as `findOne`) and assign the result to your own variable. From then on you read its fields under that variable name:

```
{% set primary = findOne("contact", "email", email) %}
{{ primary.first_name }}, {{ primary.phone }}

```

Here `primary` is a name **you** chose, it could be `contact`, `match`, `c`, or anything else. The dot-path is valid because `primary` is now a defined variable holding an associative result.

### Data from the trigger and earlier steps (in a workflow)

Inside a workflow, anything the trigger carried or earlier steps stored is under the `__data` namespace:

```
{{ __data.incoming_email.subject }}
{{ __data.last_task.due_date }}

```

See [Where it runs & its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits) for what is available in each context.

> **Tip: square brackets for awkward names.** If a key has spaces or special characters, or is held in a variable, use brackets: `{{ row['field name'] }}` or `{{ row[chosenField] }}`.

## Setting your own variables

Use `{% set %}` to name a value once and reuse it:

```
{% set fullName = first_name ~ " " ~ last_name %}
{% set vatRate = 0.20 %}

Hello {{ fullName }}, VAT is {{ vatRate * 100 }}%.

```

The `~` operator joins (concatenates) text together.

## Making decisions, `if`

Show or compute something only when a condition holds:

```
{% if amount > 10000 %}
  Priority deal, assign to a senior rep.
{% elseif amount > 1000 %}
  Standard deal.
{% else %}
  Small deal, handle via self-service.
{% endif %}

```

The short, inline form (a "ternary") is handy inside `{{ }}`:

```
{{ amount > 1000 ? "Large" : "Small" }}

```

And to supply a fallback when something is empty, use `??`:

```
{{ phone ?? "no phone on file" }}

```

## Repeating, `for`

Loop over a list of records or values:

```
{% set list = findMany("invoice", "contact_id", id, "due_date", "ASC", 50) %}
{% for inv in list %}
  Invoice {{ inv.number }}, {{ inv.total_incl_tax | number_format(2) }}
{% endfor %}

```

Inside the loop, `inv` is the **loop variable** (a name you chose) holding the current row, so `inv.number` is valid even though `invoice.number` directly would not be.

Inside a loop you get a `loop` helper with useful counters:

```
{% for item in items %}
  {{ loop.index }}. {{ item.name }}{% if not loop.last %}, {% endif %}
{% endfor %}

```

| Helper      | Meaning                     |
| ----------- | --------------------------- |
| loop.index  | Current pass, starting at 1 |
| loop.index0 | Current pass, starting at 0 |
| loop.first  | True on the first pass      |
| loop.last   | True on the last pass       |
| loop.length | Total number of passes      |

## Operators you can use

### Maths

`+` `-` `*` `/` `%` (remainder) `//` (whole-number division) `**` (power)

```
{{ (price * quantity) * (1 + vatRate) }}

```

### Comparisons

`==` (equal) `!=` (not equal) `<` `>` `<=` `>=` and membership tests `in` / `not in`:

```
{% if stage_id in [4, 5] %}...{% endif %}

```

### Logic

`and` `or` `not`

```
{% if email and not unsubscribed %}...{% endif %}

```

### Joining text

`~` joins values into one string:

```
{{ "Hi " ~ first_name ~ " " ~ last_name ~ "!" }}

```

## Tests, checking the shape of a value

```
{% if phone is defined %}...{% endif %}
{% if notes is empty %}...{% endif %}
{% if items is iterable %}...{% endif %}

```

Common tests: `is defined`, `is null`, `is empty`, `is iterable`, `is even`, `is odd`.

## Comments

Anything between `{# ... #}` is ignored, never printed, never run. Use it to leave notes for whoever edits the template next:

```
{# Discount only applies to renewals, confirmed with finance #}

```

## Inserting a field with the merge-field picker

Some editors (for example the email or template builder) offer a **merge-field picker**, a menu of available fields you can click to drop a value into your content without typing. That is the click-driven way to insert a single field value.

When you need anything beyond a plain value, formatting, a fallback, a condition, a calculation, a function, write Flexie Scripting with `{{ }}`:

```
{{ first_name | capitalize }}
{{ phone ?? "no phone on file" }}

```

The `{{ }}` form is the powerful one and is the focus of this guide.

## Global values always available

A few values are present in every script:

| Value            | What it holds                                                                                                                                 |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| LOGGED\_IN\_USER | The signed-in user running the action (their id, name, email, phone, role, timezone). Empty when no one is signed in (e.g. a background job). |
| NULL / EMPTY     | Convenient names for "nothing" or an empty string.                                                                                            |

```
Prepared by {{ LOGGED_IN_USER.full_name }} on {{ now("Y-m-d") }}.

```

Administrators can also define **custom global variables** (a company name, a support address, a default VAT rate) that then become available by name in every template. Ask your administrator what globals are defined for your account.

## Next steps

* [Function reference](https://flexie.io/resources/flexie-scripting/function-reference): the full toolbox of built-in functions.
* [Filters & collections](https://flexie.io/resources/flexie-scripting/filters-and-collections): reshaping single values and whole lists.

---

## Overview

Source: https://flexie.io/resources/flexie-scripting/overview

# Overview

Last updated 23 May 2026

![A template with a placeholder being filled in by Flexie at runtime, producing the finished result](https://flexie.io/image/resources/flexie-scripting-overview.png)

Flexie Scripting is a lightweight expression and templating language that runs **inside** Flexie. Wherever Flexie lets you type content that should change depending on the record it is working with, an email body, a document template, a workflow field value, a report, you are writing Flexie Scripting.

The simplest way to understand it:

> **You write a template with placeholders. Flexie fills the placeholders in with real data and runs any logic you added, producing the finished result.**

A plain sentence like:

```
Hi {{ first_name }}, your account was opened on {{ date(date_added, "M j, Y") }}.

```

becomes, when Flexie runs it for a real record:

```
Hi John, your account was opened on Apr 12, 2024.

```

Nothing is installed, there is no separate tool, and there is no programming environment to set up. You type Flexie Scripting directly into the fields that support it, and Flexie evaluates it at the moment it is needed.

## Who this is for

| Reader                     | What you will get from these pages                                                                                                                      |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **End users and builders** | How to insert a customer's name, format a price, show a list of their invoices, or branch a message based on a value, without writing real code.        |
| **Administrators**         | The full catalogue of available functions and filters, how data is queried safely, where scripting runs, and the security boundaries that keep it safe. |

You do not need any programming background to use the basics. The more advanced functions (querying records, building signed links, generating documents) are there for power users and administrators who want to push further.

## The two things you write

Everything in Flexie Scripting is one of two kinds of expression:

### 1\. Output, `{{ ... }}`

Double curly braces mean **"work this out and print the result here."**

```
{{ first_name }}
{{ email | lower }}
{{ now("Y-m-d") }}

```

### 2\. Logic, `{% ... %}`

Percent braces mean **"do something, but do not print anything by itself,"** like deciding whether to show a block, or looping over a list.

```
{% if amount > 1000 %}
  This is a high-value deal.
{% endif %}

{% for item in items %}
  - {{ item.name }}
{% endfor %}

```

That is the whole shape of the language: print values with `{{ }}`, control the flow with `{% %}`.

## Where you will use it

Flexie Scripting is evaluated in many places across the platform. The most common:

| Where                                  | What it powers                                        |
| -------------------------------------- | ----------------------------------------------------- |
| **Email templates**                    | Per-recipient subject lines, body, signatures         |
| **SMS templates**                      | Personalised text messages                            |
| **Snippets** (reusable content blocks) | Shared blocks you compose templates from              |
| **Document and PDF templates**         | Quotes, invoices, generated documents                 |
| **Workflow action fields**             | Any action's value, address, body, or condition field |
| **Reports**                            | Computed columns, formatted figures                   |

The exact data available to a script depends on **where** it runs (an email about a deal can see the deal; a report can query broadly). The [contexts and limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits) page explains this in full.

## The pages in this section

1. [Language basics](https://flexie.io/resources/flexie-scripting/language-basics): syntax, variables, record fields, conditions, loops, operators, and tokens. Start here.
2. [Function reference](https://flexie.io/resources/flexie-scripting/function-reference): every built-in function, grouped by what it does, with examples.
3. [Filters & working with lists](https://flexie.io/resources/flexie-scripting/filters-and-collections): transforming single values and whole collections of records.
4. [Recipes](https://flexie.io/resources/flexie-scripting/recipes): ready-to-adapt examples for the things people actually build.
5. [Where it runs & its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits): which data is available where, and the safety boundaries scripting operates within.

## A note on safety

Flexie Scripting runs in a protected sandbox. It can read and shape your data and produce output, but it cannot reach outside Flexie to touch files on the server, run arbitrary programs, or use anything that has not been deliberately made available to it. Only the functions and filters documented in this section exist. If you try to use something that is not on the list, the script stops with an error rather than doing anything unsafe. See [Where it runs & its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits).

## Next steps

* [Language basics](https://flexie.io/resources/flexie-scripting/language-basics): the syntax and the patterns.
* [Function reference](https://flexie.io/resources/flexie-scripting/function-reference): the full toolbox.
* [Recipes](https://flexie.io/resources/flexie-scripting/recipes): real examples you can paste and adapt.

---

## Flexie Scripting: Recipes

Source: https://flexie.io/resources/flexie-scripting/recipes

# Recipes

Last updated 23 May 2026

![A collection of Flexie Scripting snippets, an overdue invoice line, a tag toggle, a QR pay block](https://flexie.io/image/resources/flexie-scripting-recipes.png)

## 1\. A personalised greeting that never looks broken

**Where:** email or SMS templates, or any message body.

```
Hi {{ coalesce(first_name, "there") }},

```

(Current record = the contact.) `coalesce` returns the first value that is not empty, so a missing first name falls back to `there`. You can chain as many fallbacks as you need, `coalesce(a, b, c, "default")`.

## 2\. An overdue-invoice line

**Where:** an invoice reminder email, or a workflow email action.

Current record = the invoice.

```
{% if status != "paid" and daysBetween(due_date, now()) > 0 %}
  Invoice {{ number }} is {{ daysBetween(due_date, now()) }} days overdue.
  Amount due: {{ formatCurrency(total_incl_tax, "€", 2, ".|,", "after") }}.
{% else %}
  Thank you, your account is up to date.
{% endif %}

```

## 3\. A customer account summary block

**Where:** an account-overview email, a PDF, or a workflow note.

Current record = the account.

```
{% set dealVal = findDealsValue("account", "won", "*", id) %}
Account: {{ account_name }}
Won deals: {{ getDealStats("account", id).won }} ({{ formatCurrency(dealVal, "€") }})
Open cases: {{ getCaseStats("account", id).open }}
Outstanding invoices: {{ getInvoiceStats("account", id).pending }}

```

## 4\. List a contact's invoices, grouped and subtotalled

**Where:** a statement email or PDF.

Current record = the contact.

```
{% set invoices = findMany("invoice", "contact_id", id, "due_date", "ASC", 200) %}

{% if invoices | length == 0 %}
  No invoices on file.
{% else %}
  {% for inv in invoices | sort_by("due_date") %}
    {{ inv.number }}, due {{ date(inv.due_date, "M j, Y") }},
    {{ inv.total_incl_tax | number_format(2) }} ({{ inv.status }})
  {% endfor %}

  Total billed: {{ invoices | sum_by("total_incl_tax") | number_format(2) }}
{% endif %}

```

> Note the empty-list guard and the 200 cap, both keep the output clean and fast.

## 5\. Generate a gap-free document number

**Where:** a workflow action that sets a field (for example stamping a reference on a new record).

```
{% set seq = incrementAndGetSequenceNumber(
     "invoice", "sequence_no", "year", now("Y")
   )
%}
REF-{{ now("Y") }}-{{ padString(seq, 5, "0") }}

```

Produces values like `REF-2026-00042`. `incrementAndGetSequenceNumber` bumps the counter safely even if two records are created at the same instant, so numbers never collide or skip; `padString` pads it to a fixed width.

## 6\. Build the body of an outgoing webhook

**Where:** a workflow **Webhook** action's request-body field.

Current record = the contact.

```
{
  "external_id": "{{ id }}",
  "name": {{ (first_name ~ " " ~ last_name) | json_encode }},
  "email": {{ email | json_encode }},
  "lifetime_value": {{ findDealsValue("contact", "won", "*", id) }},
  "tags": {{ (tags | default("")) | split("|") | json_encode }}
}

```

Wrapping text values in `| json_encode` quotes and escapes them correctly, so a name with a quote or comma cannot break the JSON.

## 7\. Turn an email body into a clean SMS

**Where:** a workflow that receives an email and sends an SMS summary.

```
{{ htmlToText(__data.incoming_email.html) | truncate(140, "…") }}

```

`htmlToText` strips the formatting; `truncate` keeps it within one message.

## 8\. Add or remove a tag without losing the others

**Where:** a workflow **Update** action setting the `tags` field.

(Current record = the contact.)

```
{# Add "renewal-2026", keeping existing tags #}
{{ addTag(tags | default(""), "renewal-2026") }}

{# Remove "trial", keeping the rest #}
{{ removeTag(tags | default(""), "trial") }}

```

Tags are stored as a pipe-separated list; these helpers edit that list safely.

## 9\. Branch a message by what a list contains

**Where:** any template or workflow field.

```
{% if matchAnyTag(tags | default(""), "vip|gold") %}
  You are a priority customer, your dedicated line is +1 555 0100.
{% else %}
  Reach us any time at support@example.com.
{% endif %}

```

## 10\. A pay-by-QR block

**Where:** an invoice PDF or email.

```
Scan to pay:
{{ qrCode("https://pay.example.com/invoice/" ~ id, 2, 200, 200) }}

```

## 11\. Read JSON that arrived from another system

**Where:** a workflow triggered by a dynamic endpoint or webhook, see the [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview) section.

```
{% set order = __data.webhook | json_decode %}
Order {{ order.id }}, {{ order.items | length }} items,
total {{ jsonPath(order, "$.totals.grand") | number_format(2) }}

```

## 12\. A friendly "days since" or "days until" line

**Where:** any message body, adds a human tone instead of raw dates.

```
{% set days = daysBetween(date_added, now()) %}
{% if days == 0 %}
  joined us today
{% elseif days == 1 %}
  joined us yesterday
{% elseif days < 30 %}
  joined us {{ days }} days ago
{% else %}
  joined us {{ (days / 30) | round(0) }} months ago
{% endif %}

```

`daysBetween` is always positive, so this works both for past and future dates.

## 13\. Decide what to send by what arrived

**Where:** a workflow on an incoming case or message.

```
{% set subjectLower = subject | lower %}
{% if contains(subjectLower, "refund") or contains(subjectLower, "money back") %}
  {% snippet "support_refund_reply" %}
{% elseif contains(subjectLower, "demo") %}
  {% snippet "sales_demo_reply" %}
{% else %}
  {% snippet "support_generic_reply" %}
{% endif %}

```

Snippets keep the long bodies out of the workflow and let support edit them in one place without re-touching the automation.

## 14\. Total a contact's child records and use it as a threshold

**Where:** a workflow deciding whether a contact qualifies as VIP.

```
{% set deals = findDeals("contact", id) %}
{% set wonDeals = deals | filter(d => d.is_won) %}
{% set lifetime = wonDeals | sum_by("amount") %}

{% if lifetime >= 50000 %}
  VIP (lifetime value {{ lifetime | number_format(2) }})
{% endif %}

```

`filter` narrows a list to the items matching a condition, then `sum_by` totals one field across what is left.

## 15\. Find-or-skip: only continue if a matching record exists

**Where:** a workflow that needs a pre-existing record to act on.

```
{% set match = findOne("contact", "email", customer_email) %}
{% if match and match.id %}
  Acting on contact #{{ match.id }} ({{ match.first_name }} {{ match.last_name }})
{% else %}
  No contact for {{ customer_email }}, skipping.
{% endif %}

```

`findOne` returns an empty result rather than throwing when there is no match, so the `{% if match and match.id %}` guard is what you check.

## 16\. Turn pipe-delimited tags into a bulleted list

**Where:** an HTML email or PDF showing a contact's tags clearly.

```
{% set tagList = (tags | default("")) | split("|") | filter(t => t | trim) %}
{% if tagList | length > 0 %}
  <ul>
  {% for t in tagList | sort %}
    <li>{{ t | trim }}</li>
  {% endfor %}
  </ul>
{% endif %}

```

Splitting on `|` and filtering out empties handles records that happen to have adjacent delimiters or no tags at all.

## 17\. Build a signed, time-limited public link

**Where:** an email that links to a public resource you only want valid for a day.

```
{% set link = signUrl("https://example.com/orders/" ~ order.id, 24) %}
View your order: {{ link }}

```

`signUrl` returns a tamper-proof URL that expires in the given number of hours, so even if a recipient forwards the link, it will not keep working forever.

## 18\. Build a JWT for an outbound integration

**Where:** a workflow webhook calling a system that uses JWT auth.

```
{% set payload = {
    "sub": id | cast_string,
    "tenant": "acme",
    "exp": dateAdd(now(), 5, "minutes")
} %}
{% set token = jwtEncode(payload, "your-shared-secret", "HS256") %}

Authorization: Bearer {{ token }}

```

Put that into the Webhook action's **headers** field to authenticate the outgoing call.

## 19\. Read a value out of a deeply-nested webhook reply

**Where:** a workflow step that branches on something specific in a JSON response stored as `{{ __data.webhook }}`.

```
{% set reply = __data.webhook | json_decode %}
{% set firstItemSku = jsonPath(reply, "$.order.items[0].sku") %}
{% set grandTotal = jsonPath(reply, "$.totals.grand") | cast_float(2) %}

First item: {{ firstItemSku ?? "(none)" }}, total: {{ grandTotal | number_format(2) }}

```

`json_path` (and the `jsonPath` function) lets you reach into nested data by path rather than chaining lots of `[…]` lookups.

## 20\. A safe "numbered list" loop, with last-item handling

**Where:** any body that needs a clean numbered list.

```
{% set items = findMany("invoice", "contact_id", id, "due_date", "ASC", 50) %}
{% for inv in items %}
  {{ loop.index }}. {{ inv.number }},
  {{ inv.total_incl_tax | number_format(2) }}{% if not loop.last %},{% endif %}
{% endfor %}
{% if items | length == 0 %}No invoices on file.{% endif %}

```

`loop.index` numbers the items; `loop.last` lets you handle the final separator properly so you do not end with a trailing comma.

## Habits that keep recipes reliable

* **Always provide a fallback** for fields that might be empty (`default`, `coalesce`, or an `{% if %}`).
* **Cap and sort** any `findMany` you loop over.
* **Total in the database** with `findSum` and `findCount` when you only need a figure.
* **Encode before embedding:** `json_encode` for JSON, `url_encode` for URLs, `escape` for HTML, so special characters cannot break your output.
* **Preview against a real record** before switching anything on.

## Next steps

* [Function reference](https://flexie.io/resources/flexie-scripting/function-reference): the full toolkit these recipes draw on.
* [Where it runs & its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits): the rules these habits come from.

---

## Flexie Scripting: Where It Runs & Its Limits

Source: https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits

# Where It Runs & Its Limits

Last updated 23 May 2026

![Flexie Scripting running inside a sandbox, with access to the current record, __data, and a documented toolkit](https://flexie.io/image/resources/flexie-scripting-where-it-runs-and-limits.png)

## The record a script is given

Every place that evaluates Flexie Scripting hands it a **record to work on** plus the always-available [global values](https://flexie.io/resources/flexie-scripting/language-basics). What that record is depends on the context:

| Where it runs                          | The record it is given                           |
| -------------------------------------- | ------------------------------------------------ |
| An email template sent about a contact | that contact                                     |
| An invoice PDF template                | that invoice                                     |
| A quote PDF template                   | that quote                                       |
| A workflow action on a deal            | that deal                                        |
| An SMS template                        | the message's recipient record                   |
| A snippet                              | the same record as the template that included it |

You read that record's fields directly, `{{ first_name }}`, `{{ total_incl_tax }}`, with **no `record.` prefix**. To work with any **other** record (a related lead, a recent invoice, the linked account), use a [look-up function](https://flexie.io/resources/flexie-scripting/function-reference) such as `findOne`, `findMany`, or `getAccountContacts`, and assign the result to a variable of your own.

> **Built-in related arrays.** In a workflow whose record type has standard relations, for example a Deal, which has one linked Account and many linked Contacts, those related records are also exposed automatically as arrays under the plural name: `{{ contacts[0].first_name }}`, `{{ accounts[0].account_name }}`. Use `[0]` to take the first (or only) one.

## The `__data` namespace (inside workflows)

When a script runs **inside a workflow**, it also has access to everything the workflow has gathered so far, under a single namespace called `__data`.

This is how data flows from one step to the next. When a workflow is triggered by an incoming signal (an email arrives, a form is submitted, a webhook is received), or when an earlier action stored a value, that information is available to every later step as `{{ __data.something }}`:

```
{{ __data.incoming_email.subject }}
{{ __data.incoming_sms.text }}
{{ __data.last_task.due_date }}

```

The full mechanics of `__data`, what each trigger provides, and how to store your own values for later steps, are covered in [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps). For dynamic endpoints, the incoming request body is also exposed this way, see [Dynamic Endpoints, Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data).

## Result limits

To keep templates fast and safe, look-ups that can return many rows are **capped at 1,000 results**:

* `findMany(...)` defaults to 1,000 and will not exceed it.
* `query(...)` is capped at 1,000 rows.

If you need totals across more than that, total at the source with `findSum`, `findCount`, `findMin`, `findMax` (which compute in the database) rather than pulling every row back and adding them up in the template.

`query(...)` is **read-only**: only `SELECT` and `WITH` are accepted. Anything that would change or remove data (`INSERT`, `UPDATE`, `DELETE`, `DROP`), and `SELECT *`, are rejected. You will get an `{"error": "…"}` result instead.

## The safety sandbox

Flexie Scripting runs inside a protected sandbox. This is what keeps it safe to expose in templates and workflow fields. The boundaries:

### Only the documented toolkit exists

Only the **functions**, **filters**, and **tags** listed in this section are available. If a script uses anything else, it stops with an error rather than doing something unexpected. The available tags are exactly:

* `{% if %}` / `{% elseif %}` / `{% else %}` / `{% endif %}`
* `{% for %}` / `{% endfor %}`
* `{% set %}`
* `{% snippet "alias" %}`

(There is no "include a file," "import," "macro," or similar, those are deliberately not available.)

### You read data, you do not call methods on it

Records are provided to your script as plain data, so reading fields works exactly as shown: `{{ email }}`, `{{ total_incl_tax }}`, `{{ row['some key'] }}` (where `row` is a variable you set from a look-up). What you **cannot** do is call methods or reach internal properties on objects; the sandbox does not permit it. Everything you need is exposed either as readable record data or as one of the documented functions.

### It cannot reach outside Flexie

A script cannot read or write files on the server, run programs, or use anything that has not been deliberately made available. The only ways a script touches the outside world are through the dedicated, controlled functions documented here (for example a webhook is sent by a **workflow action**, not by the template language itself).

### Errors are contained

When a script fails, a bad function name, malformed input, it raises an error in that one place. It does not crash the surrounding page or corrupt data.

## Practical implications

* **Test with a real record.** Because a script depends on the record it is given, always preview against a real example before going live. Workflows have a built-in test mode (see [Scheduling, testing & troubleshooting](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting)); templates have a preview.
* **Guard against empty values.** A field can be blank. Use `default(...)`, `coalesce(...)`, or an `{% if %}` so a missing value does not produce ugly output.
* **Prefer database-side totals.** `findSum` and `findCount` over fetching rows and adding them up, faster, and never hits the 1,000-row cap.
* **Keep heavy look-ups out of tight loops.** Calling `findMany` inside a `for` loop that itself runs over many records multiplies the work. Fetch once, then loop.

## Next steps

* [Recipes](https://flexie.io/resources/flexie-scripting/recipes): complete, real examples that respect these limits.
* [Function reference](https://flexie.io/resources/flexie-scripting/function-reference): the full toolkit.

---

## Creating a Form

Source: https://flexie.io/resources/forms/creating-a-form

# Creating a Form

Last updated 25 May 2026

![The Flexie form builder with a field palette on the left and a live preview of the form on the right](https://flexie.io/image/resources/forms-creating-a-form.png)

The same flow applies to all three flavours; the differences are noted as you go. Start at the main menu under **Forms** (`/forms`), click **New**.

## Step 1, the three first choices (you can't change them later)

When you create a form, three settings are locked once it has been saved:

| Setting         | What it controls                                                                                                                                                                                                                                           |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**        | The form's display name in lists, emails, the URL slug, and reports. You _can_ change this later.                                                                                                                                                          |
| **Form type**   | **External** (public-facing) or **Internal** (for signed-in users). **Locked after save.**                                                                                                                                                                 |
| **Record type** | The kind of record this form is attached to: Lead, Contact, Deal, Case, a custom record, or the **virtual** type for forms that aren't tied to one record. **Locked after save.** Only applies to Internal forms; External forms always submit as virtual. |

If you realise the choice was wrong later, you'll need to create a new form and copy the field layout across. Choose deliberately.

The fields you'll set on the create screen:

* **Name**, required.
* **Alias**, a machine-readable name (auto-generated from the name).
* **Category**, a folder, optional.
* **Form type**, `External` or `Internal`.
* **Record type**, only shown if Form type is Internal.
* **Create workflow automatically?**, if ticked, Flexie creates a starter workflow with the matching listener wired up, so you can start adding steps straight away. Recommended for new forms.

Click **Save** and you're in the **form builder**.

## Step 2, the form builder (the visual canvas)

The builder is a **drag-and-drop canvas**. On the left is the palette of field types; on the right is the live form, exactly as a submitter will see it. You add fields by dragging them from the palette onto the form.

There are two **layouts** you can choose for the form:

* **Single-page form** (the default), all fields on one screen.
* **Wizard**, a multi-step flow where each step is a separate "page" of the form. The submitter clicks **Next** to move through them.

You set this when you create the form (or change it via the builder's view control, before fields are added). Inside a wizard, each step has its own title and its own set of fields.

## Step 3, field types

The field palette offers these field types. The first group are **data fields** (they collect a value); the second group are **layout fields** (they just arrange the form).

### Data fields

| Field                 | What it's for                                                                        | Notable settings                                                                                                   |
| --------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
| **Text Field**        | A single-line text input (name, ID, postcode)                                        | Required, default value, placeholder, word count, character count                                                  |
| **Text Area**         | Multi-line text (notes, descriptions)                                                | Same as Text Field                                                                                                 |
| **Email**             | An email address; the form validates the format on the client before submission      | Required, default value                                                                                            |
| **Phone Number**      | A phone number (no automatic format validation)                                      | Required, default value                                                                                            |
| **Number**            | A number; submitter can only enter digits                                            | Required, default value, min / max                                                                                 |
| **Checkbox**          | A yes/no tick box                                                                    | Required, default state                                                                                            |
| **Select / Dropdown** | A single choice from a list                                                          | The list of options (each option has a _label_ shown to the user and a _value_ stored), required, default value    |
| **Radio Buttons**     | A single choice as a row of buttons                                                  | Same as Select                                                                                                     |
| **Date**              | A calendar picker                                                                    | Required, default value, date format                                                                               |
| **Time**              | A time picker                                                                        | Required, default value                                                                                            |
| **File Upload**       | One or more files attached to the submission                                         | Single or multiple files (see [File uploads](https://flexie.io/resources/forms/public-forms#file-uploads-allowed-types-and-limits)) |
| **GDPR Consent**      | A consent block, used to group one or more checkboxes around a legal-basis statement | Contains its own sub-fields                                                                                        |

### Layout fields (no data)

| Field       | What it's for                                              |
| ----------- | ---------------------------------------------------------- |
| **Content** | A free-form HTML block: headings, explanatory text, images |
| **Panel**   | A collapsible / expandable group of fields with a heading  |
| **Columns** | A multi-column row to place fields side by side            |
| **Line**    | A visual separator                                         |
| **Button**  | The Submit (or Next, in a wizard) button                   |

> **Every data field has a `key`.** It's what the submission JSON uses to label that value. For example a field called _"First Name"_ probably has the key `First Name`. The key is also what your workflow steps read from `__data` (see [Reading submissions](https://flexie.io/resources/forms/submissions#reading-a-submission-in-a-script)). The key can contain spaces and special characters, which has implications for how you read it in scripts, covered in [Submissions](https://flexie.io/resources/forms/submissions#bracket-notation-for-keys-with-spaces).

## Step 4, per-field settings

Click any field on the canvas to open its settings panel. The settings vary by field type, but the common ones are:

| Setting                       | Effect                                                                           |
| ----------------------------- | -------------------------------------------------------------------------------- |
| **Label**                     | The visible text next to the input.                                              |
| **Key**                       | The system name, what the value is stored as. Auto-generated from the label.     |
| **Required**                  | The form won't submit without a value.                                           |
| **Default value**             | What the field starts with when the form is loaded.                              |
| **Placeholder**               | Faded hint text inside the empty input.                                          |
| **Custom validation message** | The error message shown when validation fails (otherwise a generic one is used). |
| **Description / tooltip**     | Extra hint text shown beside or below the field.                                 |

For Select and Radio fields, you also configure the **list of options**: each option has a _label_ (shown) and a _value_ (stored).

### Validation

Validation happens in the submitter's browser before the form is sent. The built-in checks are:

* **Required**, the field has a value.
* **Type-correct**, Email looks like an email; Number is numeric; Date is a real date.
* **Length / min / max**, where supported by the field type.

If a field fails validation, the form is **not** submitted. The user sees an inline error and the relevant field is highlighted.

> Some abusive submitters bypass the client-side validation by posting straight to the submit URL. For external forms, layer a **reCAPTCHA** on top, see [Spam protection](https://flexie.io/resources/forms/public-forms#spam-protection-google-recaptcha-v3).

## Step 5, form-level settings

Open the form's **Settings** (separate from the field-level settings) to configure:

### Identity

* **Name**, the form's display name.
* **Alias**, auto-generated; rarely needs editing.
* **Category**, optional folder.
* **Published**, the on/off switch. **An unpublished form rejects every submission**, even if its URL is reachable. Always publish before going live.

### Layout & design

* **Form image**, a hero image at the top of the form.
* **Accent colour**, the colour of buttons and highlights.
* **Optimise uploaded images**, when on, image attachments are converted to a smaller, web-friendly format on upload (saves storage and bandwidth).

### Post-submit behaviour (External forms only)

What the submitter sees right after they submit. Two options:

* **Show a message**, a confirmation message you write (Flexie Scripting allowed).
* **Redirect to a URL**, send them on to a thank-you page.

These are the _defaults_. A workflow can override the response per-submission using the **Form Respond** action, see [Writing a custom response](https://flexie.io/resources/forms/forms-in-workflows#writing-a-custom-response-per-submission).

### Spam protection, Google reCAPTCHA v3 (External forms)

Covered in [Public forms: Spam protection](https://flexie.io/resources/forms/public-forms#spam-protection-google-recaptcha-v3).

### Analytics (External forms)

* **Google Analytics tracking ID** (e.g. `UA-…` or `G-…`), emits a form-submit event when the form is sent.
* **Anonymise IP**, sets the `anonymizeIp` flag for GA, for GDPR compliance.
* **Facebook Pixel ID**, fires a Lead event on submit.

### Legal basis (External forms)

For GDPR compliance you must declare a legal basis for processing submitted data. The form requires you to choose one (Consent, Contract, Legal obligation, Vital interests, Public task, Legitimate interests, Pre-contractual measures).

### Access (Internal forms)

Who can see and use the form: everyone, or specific roles, user groups, or individual users. See [Internal forms: Access control](https://flexie.io/resources/forms/internal-forms#access-control).

### Placement (Internal forms)

Where the form should appear in the app: on the record's profile, in the top navigation, in the dialer, or any combination. See [Internal forms: Where the form appears](https://flexie.io/resources/forms/internal-forms#where-the-form-appears).

## Step 6, test before going live

Before publishing:

1. **Open the form** as a submitter would. For an External form, open `/form/{identifier}`; for an Internal form, find it on a record's profile or in the top-nav.
2. **Submit a real test** with realistic values.
3. **Check it landed** in the right place, see [Submissions](https://flexie.io/resources/forms/submissions#viewing-submissions).
4. **Check the workflow it triggers**, open the workflow's [Logs view](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting#the-activity-logs) to confirm each step ran with the values you expected.
5. If your form uses **reCAPTCHA**, test from a normal browser session. A headless test can fail the score check.

Fix anything you find, then publish.

## What is _not_ configurable

A few things are intentionally fixed:

* **The submission endpoint URL.** External forms post to `/form/push/{identifier}` regardless of how you embed them. You can't change the path; you can only change the host (your Flexie instance).
* **The data shape sent back by the workflow.** The form-respond pattern has four fixed response types (`message`, `redirect`, `error`, `json`), see [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows#response-shape).
* **Form type and record type** after creation, as noted at the top of this page.

## Next steps

* For an External / public form: [Public forms](https://flexie.io/resources/forms/public-forms).
* For an Internal form: [Internal forms](https://flexie.io/resources/forms/internal-forms).
* After you've collected some submissions: [Submissions](https://flexie.io/resources/forms/submissions).
* To make the form drive an automation: [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows).

---

## Forms in Workflows

Source: https://flexie.io/resources/forms/forms-in-workflows

# Forms in Workflows

Last updated 25 May 2026

![A form on the left triggering a workflow on the right, with a Form Respond action writing a custom reply back to the submitter within 20 seconds](https://flexie.io/image/resources/forms-forms-in-workflows.png)

If you've used [Workflows](https://flexie.io/resources/workflows/overview) and [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview), everything on this page will feel familiar. It is the same `__data` notepad and the same kind of listener / action wiring, just specific to forms.

## The three form-submit listeners

Every form-submit event lands as a workflow listener you can use as the **source** of a workflow (the very first step). Which listener applies depends on the form's flavour:

External (public)

Listener key

`virtual_workflow.form_submit` 

Workflow record type

`__virtual` 

Fields land at

`__data.form_submission.<key>` 

Internal, entity-bound

Listener key

`form.internal_submit` 

Workflow record type

The record type the form is bound to (Lead, Contact, Deal, …) 

Fields land at

`__data.internal_form_submission.data.<key>` 

Internal, virtual

Listener key

`virtual_workflow.internal_virtual_entity_submit` 

Workflow record type

`__virtual` 

Fields land at

`__data.internal_form_submission.data.<key>` 

When you build a workflow whose source is "Listener" and pick one of these listeners, the builder hides the listeners that don't apply to the workflow's record type, so you can't accidentally pair the wrong listener with the wrong record type.

## 1\. The external (public) form listener

**Listener key**: `virtual_workflow.form_submit` **Workflow record type**: `__virtual`

### What you get in `__data`

```
{
  "form_submission": {
    "<form field key>": "<submitted value>",
    "<form field key>": "<submitted value>",
    "attachments": [
      { "...file metadata..." }
    ]
  }
}

```

Fields are **directly under** `form_submission`, with no nested `data` wrapper and **no metadata about the submitter**, public submissions are anonymous.

### Reading values

```
{# Form had fields "First Name", "Email", "Notes" #}
Hi {{ __data.form_submission['First Name'] }},

We received your message:
{{ __data.form_submission.Notes }}

We'll reply to {{ __data.form_submission.Email }}.

```

(Bracket notation for keys with spaces, see [Submissions: bracket notation](https://flexie.io/resources/forms/submissions#bracket-notation-for-keys-with-spaces).)

### Useful patterns

**Create a lead from a public form submission:**

1. Trigger: this listener.
2. Decision: check `{{ __data.form_submission['Email'] }}` is not empty.
3. Action: Create a Lead with field values pulled from `__data.form_submission.<key>`.
4. Action: write a custom response back to the submitter, see [Writing a custom response](#writing-a-custom-response-per-submission).

## 2\. The internal entity-bound form listener

**Listener key**: `form.internal_submit` **Workflow record type**: The record type the form is bound to (Lead, Contact, …).

### What you get in `__data`

```
{
  "internal_form_submission": {
    "date_added": "2026-05-25 12:34:56",
    "__submitted_from_user_id": 7,
    "__submitted_from_user_full_name": "John Doe",
    "data": {
      "<form field key>": "<submitted value>",
      "<form field key>": "<submitted value>"
    }
  }
}

```

Notice the **two differences** versus the external form:

* The root key is **`internal_form_submission`**.
* Fields are nested under a **`data` sub-key**, alongside submitter metadata.

Plus, because the workflow runs **on the record the form was opened against**, that record's fields are also available **at the top level**:

```
Contact's first name (from the record):    {{ first_name }}
Form's first-name field (from submission): {{ __data.internal_form_submission.data['First Name'] }}

```

### Useful patterns

**Update the record from the form:**

1. Trigger: this listener.
2. Action: Update the contact, setting fields from `__data.internal_form_submission.data.<key>`.

**Audit who did it:**

```
{# In a workflow step's "Add a note" action #}
Form "Qualification" submitted by
{{ __data.internal_form_submission.__submitted_from_user_full_name }}
on {{ date(__data.internal_form_submission.date_added, "M j, Y H:i") }}.

```

## 3\. The internal virtual form listener

**Listener key**: `virtual_workflow.internal_virtual_entity_submit` **Workflow record type**: `__virtual`

### What you get in `__data`

```
{
  "internal_form_submission": {
    "__submitted_from_user_id": 7,
    "__submitted_from_user_full_name": "John Doe",
    "data": {
      "<form field key>": "<submitted value>"
    }
  }
}

```

Same root and same nesting as entity-bound, **but no `date_added`** and **no current record fields** (the workflow runs on the virtual type).

### Useful patterns

**Spawn a new record from a virtual form:**

1. Trigger: this listener.
2. Action: Create a Lead / Contact / Case with the fields from `__data.internal_form_submission.data.<key>`.
3. Optional: Store the new record's id (`__data.__entity_inserted_id`) and continue with steps that need it.

**Stamp a timestamp yourself:**

Because this listener doesn't include `date_added`, use `now()` in your first step to capture the moment:

```
{% set submittedAt = now() %}

```

…and then write that into any record you create.

## Side-by-side: which root, nesting, metadata?

External (public)

Listener key

`virtual_workflow.form_submit` 

Workflow record type

`__virtual` 

`__data` root

`form_submission` 

Fields nested under

(the root, no `data` wrapper) 

`date_added`

– 

Submitter user id / name

– 

Top-level record fields

– 

Internal, entity-bound

Listener key

`form.internal_submit` 

Workflow record type

The bound type (Lead, Contact, …) 

`__data` root

`internal_form_submission` 

Fields nested under

`data` 

`date_added`

✓ 

Submitter user id / name

✓ 

Top-level record fields

✓ (the bound record) 

Internal, virtual

Listener key

`virtual_workflow.internal_virtual_entity_submit` 

Workflow record type

`__virtual` 

`__data` root

`internal_form_submission` 

Fields nested under

`data` 

`date_added`

– 

Submitter user id / name

✓ 

Top-level record fields

– 

Bookmark this; it is the cheat-sheet that prevents the most common form-workflow mistake (wrong path to the value).

## Pushing a form to a user mid-workflow

### The "Trigger Internal Form" action

A workflow can **send a form to a signed-in user during its execution**, then continue once the user submits.

The action's settings:

| Setting                               | What it sets                                                                                          |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| **Which form**                        | The internal form to push. (Must be an internal form.)                                                |
| **Which user**                        | The current owner, a specific user, the user who triggered the workflow, or any rule-based selection. |
| **(Entity-bound forms) Which record** | The record the submission should attach to, usually the current record the workflow is running on.    |

The action is **immediate**, it doesn't queue the step. The form appears for the chosen user in their interface immediately, and the workflow's next step runs once that user submits the form. If you need to time out a long wait (e.g. "if no one fills it in within 24 hours, escalate"), pair this with a [restricted-hours-style branch](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting#restricted-hours-and-skip-days).

There are two action variants:

* **`form.triggerinternal`**, for workflows on a real record type (the form is attached to that record).
* **`form.triggerinternal.virtual`**, for workflows on the virtual record type.

The builder shows you the right one for the workflow you're in.

## Writing a custom response per-submission

This is the pattern that turns a form into a small **request/response API**: the submitter waits a moment after clicking Submit while the workflow decides what to say, then sees a reply tailored to what they entered.

### How it works

1. The submitter clicks Submit.
2. Flexie stores the submission and starts the workflow.
3. The frontend **polls for up to 20 seconds** waiting for the workflow to write a response.
4. The workflow has a **Form Respond** action somewhere in its tree that produces the response.
5. When that action runs, the response is delivered to the polling submitter and they see it.
6. If 20 seconds pass with no Form Respond action firing, the form falls back to its **default post-submit behaviour** (the message or redirect set in the form's Settings).

### The "Form Respond" action

The action has two variants:

* **`form.form_respond`**, for entity-bound internal-form workflows.
* **`virtual_workflow.form_respond`**, for external-form and virtual-form workflows.

The settings:

| Setting            | What it does                                              |
| ------------------ | --------------------------------------------------------- |
| **Response type**  | One of message, redirect, error, json (see below).        |
| **Response value** | The body of the response, computed with Flexie Scripting. |

### Response shape

There are exactly four response types. Pick the one that matches what the submitter's browser should do:

| Response type | What the submitter sees                                                                     | Useful for                                                                                                                                    |
| ------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| message       | A confirmation message shown on the form                                                    | "Thanks, we'll be in touch with you at {{ \_\_data.form\_submission.Email }}."                                                                |
| redirect      | The browser navigates to a URL                                                              | Sending them to a thank-you page that depends on what they submitted                                                                          |
| error         | A red error message shown on the form (the form stays open with their input still in place) | Rejecting a submission with a reason ("This email is already on file, please log in instead.")                                                |
| json          | A raw JSON body                                                                             | When your front-end is calling the form's submit URL via JavaScript and wants the response programmatically rather than as a rendered message |

### Example, branched custom message

```
Trigger:  Listener — virtual_workflow.form_submit
Step 1:   Decision — does {{ __data.form_submission['Email'] }}
          match an existing contact?

  Yes ─►  Form Respond (error):
          "An account already exists for that email,
           please reset your password."

  No  ─►  Step 2: Create a Contact
          Step 3: Form Respond (redirect):
          "https://www.yoursite.com/welcome
            ?id={{ __data.__entity_inserted_id }}"

```

### Timing notes

* The polling window is **20 seconds**. A Form Respond action that fires later than that doesn't reach the submitter; only the **default** response does.
* If your workflow takes a long time before reaching the Form Respond step (e.g. it makes a slow webhook call first), consider letting the form return its default response and doing the long work asynchronously, then notifying the submitter another way (email, SMS).
* The form's **default response** (set in form Settings) is always the fallback. It's worth making it sensible on its own ("Thanks, we'll be in touch soon") rather than relying on Form Respond always firing in time.

## Pairing forms with other workflow building blocks

Forms slot into the same workflow patterns as any other listener trigger:

* [Virtual conditions](https://flexie.io/resources/dynamic-endpoints/virtual-conditions): branch on the values in `__data.form_submission.*` or `__data.internal_form_submission.data.*`.
* [Lookups](https://flexie.io/resources/flexie-scripting/function-reference#1-looking-up-records): use `findOne` / `findMany` to check whether a submitted value already exists in your data.
* [The webhook action](https://flexie.io/resources/workflows/actions-and-decisions#logic-and-integration): forward the submission to another system.
* [The AI step](https://flexie.io/resources/workflows/actions-and-decisions#logic-and-integration): have AI classify the submission ("does this look like a sales lead or a support question?") and branch.

## Quick reference card

```
EXTERNAL public form
  listener:           virtual_workflow.form_submit
  record type:        __virtual
  read fields as:     {{ __data.form_submission['<key>'] }}
  no submitter info, no date

INTERNAL entity-bound form
  listener:           form.internal_submit
  record type:        the bound type (Lead, Contact, …)
  read fields as:     {{ __data.internal_form_submission.data['<key>'] }}
  read submitter as:  {{ __data.internal_form_submission.__submitted_from_user_full_name }}
  read timestamp as:  {{ __data.internal_form_submission.date_added }}
  top-level fields:   the record's own fields (e.g. {{ first_name }})

INTERNAL virtual form
  listener:           virtual_workflow.internal_virtual_entity_submit
  record type:        __virtual
  read fields as:     {{ __data.internal_form_submission.data['<key>'] }}
  read submitter as:  {{ __data.internal_form_submission.__submitted_from_user_full_name }}
  (no date_added — use now() if you need one)

WORKFLOW ACTIONS
  form.triggerinternal            push an internal entity-bound form to a user
  form.triggerinternal.virtual    push an internal virtual form to a user
  form.form_respond               write custom response (entity-bound)
  virtual_workflow.form_respond   write custom response (external / virtual)

RESPONSE TYPES (for *form_respond actions)
  message    — confirmation message on the form
  redirect   — send the browser to a URL
  error      — red error message, form stays open
  json       — raw JSON body for JS callers

RESPONSE WINDOW
  20 seconds from submit; after that, the form's default response is used.

```

## Back to

* [Forms overview](https://flexie.io/resources/forms/overview): the section map.
* [Submissions](https://flexie.io/resources/forms/submissions): viewing what's been collected.
* [Workflows](https://flexie.io/resources/workflows/overview): the wider automation engine.

---

## Internal Forms

Source: https://flexie.io/resources/forms/internal-forms

# Internal Forms

Last updated 25 May 2026

![An entity-bound form open inside a contact profile, and a virtual form pinned to the top-nav of Flexie](https://flexie.io/image/resources/forms-internal-forms.png)

A form is **Internal** when its Form type was set to "Internal" at creation. The sub-flavour is decided by its **record type**:

* A real record type (Lead, Contact, Deal, Case, Invoice, Quote, a custom record type) → **entity-bound** internal form.
* The **virtual** record type → **virtual** internal form.

Both share the same builder, fields, and settings; they differ in _where_ they appear and _what_ the workflow listener gets.

## Entity-bound internal forms

### What they are

A form attached to a specific record type. When your team is looking at, say, a Contact's profile, they can open this form to fill in some structured information **about that contact**. The submission is stored against that contact, and the workflow that fires can read both:

* The submission's field values
* The current state of the record itself (because it's running on the contact)

### Where the form appears

Open the form's **Settings** to decide where it surfaces:

| Setting                    | Effect                                                                                                                              |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Show on profile**        | Adds a button or panel to the record's profile so the form is available from there (default: on).                                   |
| **Show in top navigation** | Adds a quick-launcher entry to the top bar so a user can open the form from anywhere, but it will still need a record to attach to. |
| **Show in dialer**         | Adds the form to the dialer panel, useful for call-logging forms.                                                                   |
| **Icon**                   | The icon shown next to the form's name in those menus (a Font Awesome class such as far fa-plus-square).                            |

You can tick any combination.

### Prefill, values pulled from the record

The form **pre-fills** any field whose key matches a field on the record. So a form with a field keyed `email` opened against a contact whose `email` is `john@example.com` will start with that email already in the box. The user can edit it before submitting.

This is automatic, no configuration needed. It works because the field's **key** (set in the field's per-field settings) is matched against the record's field aliases. If you want a prefill, give the field the same key as the record's field alias (which you can find in the relevant Custom Fields page, e.g. `/contact-fields`).

### Access control

By default an internal form is visible to everyone who can use Flexie. To restrict it, set **Form access** in the form's Settings. You can grant access by any combination of:

* **Permissions**, anyone whose role is in the list.
* **Groups**, members of a user group.
* **Users**, specific people by name.

A user must match at least one entry to see the form.

### What the workflow listener gets

The listener key is **`form.internal_submit`**, and the submission's data lands under `__data.internal_form_submission`:

```
{{ __data.internal_form_submission.data['First Name'] }}
{{ __data.internal_form_submission.data['Notes'] }}

{{ __data.internal_form_submission.date_added }}
{{ __data.internal_form_submission.__submitted_from_user_id }}
{{ __data.internal_form_submission.__submitted_from_user_full_name }}

```

Notice:

* The form's field values are nested under a `data` key.
* The submitter (the signed-in user) is identified via `__submitted_from_user_id` and `__submitted_from_user_full_name`.
* A `date_added` timestamp is provided.

Because the workflow runs on the record the form was opened against, you also have all of **that record's fields at the top level** (e.g. `{{ id }}`, `{{ email }}`). See [Reading records](https://flexie.io/resources/flexie-scripting/language-basics#reading-record-fields) for the rule.

## Virtual internal forms

### What they are

A form **not tied to any one record**, surfaced in the top navigation or dialer as a quick action your whole team can run from anywhere. There's no profile to attach the submission to; the submission stands alone.

Use it for things like:

* A "log a callback" form that captures a number + a follow-up time.
* A "report an issue" form that creates a case.
* An "intake" form that always creates a new lead from scratch.

### Where it appears

Same Settings options as entity-bound forms (**Show in top navigation**, **Show in dialer**), except there's no profile to "Show on profile", because there's no record type.

### What the workflow listener gets

The listener key is **`virtual_workflow.internal_virtual_entity_submit`**, and the submission's data lands under `__data.internal_form_submission`:

```
{{ __data.internal_form_submission.data['First Name'] }}
{{ __data.internal_form_submission.__submitted_from_user_id }}
{{ __data.internal_form_submission.__submitted_from_user_full_name }}

```

Notice, compared to the entity-bound listener:

* Field values are still nested under `data`.
* Submitter id and name are still there.
* **There is no `date_added`** in the enrichment from this listener. If you need the moment of submission, use `now()` in your first step.
* The workflow runs on the **virtual** record type, so there are no top-level record fields. Everything comes from `__data`.

## The two listeners side by side

|                                               | Entity-bound (form.internal\_submit)              | Virtual (virtual\_workflow.internal\_virtual\_entity\_submit) |
| --------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------- |
| **Workflow record type**                      | The record's type (Lead, Contact, …)              | \_\_virtual                                                   |
| **\_\_data root**                             | internal\_form\_submission                        | internal\_form\_submission                                    |
| **Field values under**                        | …data.<key>                                       | …data.<key>                                                   |
| **Submitter user id**                         | …\_\_submitted\_from\_user\_id                    | …\_\_submitted\_from\_user\_id                                |
| **Submitter user name**                       | …\_\_submitted\_from\_user\_full\_name            | …\_\_submitted\_from\_user\_full\_name                        |
| **date\_added**                               | **Yes**                                           | **No**                                                        |
| **Current record fields available top-level** | Yes, fields of the record the form opened against | No, there is no record                                        |

If you build internal forms regularly, this table is worth bookmarking.

## Pushing a form to a user from a workflow (the "trigger internal form" action)

A workflow can **send a form to a user mid-flow** and pause for them to fill it in. This is the **Trigger Internal Form** action.

Example flow:

1. _Trigger_: a new high-value lead is assigned.
2. _Step 1_: **Trigger Internal Form** "Qualification Questions", routed to the lead's owner.
3. _Step 2_: once they submit, branch on the answers and continue.

The action accepts:

* **Which form** to push.
* **Which user** to send it to (the record's owner, a specific user, the current user).
* (For entity-bound flows) **Which record** to attach it to.

The action is **immediate**, it doesn't queue. The form appears for the chosen user in their interface, and the workflow's next step runs once the user submits.

This is covered in [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows#pushing-a-form-to-a-user-mid-workflow).

## Tips and pitfalls

* **Don't put the same form on both top-nav and profile** without thinking about the difference. From a profile it opens _attached_ to that record; from the top-nav it opens _unattached_ (requires picking one), or it submits as virtual if its record type is virtual.
* **Match field keys to record aliases** for fields you want pre-filled. If you name a field "First Name" but the record's field alias is `first_name`, prefill won't work. Change the field key to match the alias.
* **Access control is OR, not AND.** A user matching _any_ of the listed roles, groups, or users gets in.
* **A virtual internal form doesn't fire on a profile** even if you tick "Show on profile", because it has no record type to bind to. The setting only affects entity-bound forms.

## Next steps

* [Submissions](https://flexie.io/resources/forms/submissions): viewing what your team has logged.
* [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows): the full listener and action reference.
* [Public forms](https://flexie.io/resources/forms/public-forms): the other flavour.

---

## Overview

Source: https://flexie.io/resources/forms/overview

# Overview

Last updated 25 May 2026

![A Flexie form sitting between a public visitor on the left and a workflow firing on the right, with the submission stored in the middle](https://flexie.io/image/resources/forms-overview.png)

A Form is a structured way of **collecting information**, either from people outside Flexie (sign-ups, contact requests, applications) or from your own team inside Flexie (creating a record from a quick panel, updating fields, logging a call note).

In every case the principle is the same:

> **Someone fills the form. Flexie stores the submission. A workflow can react instantly.**

What changes between use-cases is _who fills it in_, _where they fill it in_, and _what record (if any) it is attached to_. That is why Flexie has **three form flavours**, and choosing the right one is the most important decision when you create a form.

## The three flavours of Form

| Flavour                     | Who fills it                                          | Where it lives                                                      | What it produces                                                                                                 |
| --------------------------- | ----------------------------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **External**                | Anyone, usually a customer or prospect, with no login | A public URL /form/{identifier}, or embedded on your own website    | A submission stored against the form, plus a workflow trigger                                                    |
| **Internal (entity-bound)** | A signed-in team member                               | A button or panel on a record's profile (Lead, Contact, Deal, Case) | A submission stored **against that record**, plus a workflow trigger that can read the record and the submission |
| **Internal (virtual)**      | A signed-in team member                               | The top-navigation quick menu, or the dialer                        | A submission stored on its own (no record attached), plus a workflow trigger                                     |

You choose the flavour when you create the form, and it is **fixed** afterwards. The form's _type_ and _bound record type_ can't be changed once the form exists. Pick deliberately.

### Quick decision guide

| You want to…                                                  | Use                                    |
| ------------------------------------------------------------- | -------------------------------------- |
| Collect leads from your website                               | **External**                           |
| Take a job application or quote request from the public       | **External**                           |
| Add a structured note to a contact from the contact's profile | **Internal (entity-bound)** to Contact |
| Update specific fields on a deal from a quick panel           | **Internal (entity-bound)** to Deal    |
| Let support agents log a callback through the top-bar         | **Internal (virtual)**                 |
| Start an internal workflow that isn't tied to any one record  | **Internal (virtual)**                 |

## The lifecycle of a submission

Whatever the flavour, the flow is the same shape:

1. **Form rendered**, on a public URL for a visitor or in a profile/top-nav panel for a teammate.
2. **Submitted**, the form posts to Flexie. Uploads go to cloud storage; the submission is stored.
3. **Workflow fires**, the listener picks it up. Steps run, and a Form Respond action can optionally write a response back to the submitter.

What "stored" looks like and what the listener gets depends on the flavour, but every form ends with the same `__data` notepad your workflow steps can read. The [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows) page is the reference for that shape.

## What is in this section

1. [Creating a form](https://flexie.io/resources/forms/creating-a-form): the builder, the field types, validation, the settings every form has, and the choice between single-page and wizard.
2. [Public (external) forms](https://flexie.io/resources/forms/public-forms): the public URL, the embed snippet for your website, security (reCAPTCHA), analytics, and the post-submit response.
3. [Internal forms](https://flexie.io/resources/forms/internal-forms): entity-bound forms on record profiles, virtual forms in the top-nav and dialer, prefill from the record, icon and placement, and access control.
4. [Submissions](https://flexie.io/resources/forms/submissions): where submissions are stored, how to view them, and how to read them safely in Flexie Scripting (including the bracket notation for keys with spaces).
5. [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows): the three listeners (one for each flavour) with their exact `__data` shape, the form-related workflow actions (push a form to a user, write back a response), and the request/response polling pattern.

## Closely related

* [Workflows](https://flexie.io/resources/workflows/overview): a form's submission almost always starts a workflow. Forms are arguably the most common workflow trigger after record events.
* [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview): when you need a web URL but don't need a form's visual builder (e.g. a system-to-system webhook), use a Dynamic Endpoint instead.
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): reading the submission data from inside workflow steps.

## Who should read what

* **End users and builders**: _Creating a form_, _Public forms_ or _Internal forms_ (whichever applies), and _Submissions_.
* **Administrators**: also read _Forms in workflows_ and the access control section of _Internal forms_.
* **Developers integrating a Flexie form into their website**: the embed section of _Public forms_.

---

## Public (External) Forms

Source: https://flexie.io/resources/forms/public-forms

# Public (External) Forms

Last updated 25 May 2026

![A public Flexie form embedded on a website with a script tag, posting to Flexie on submit](https://flexie.io/image/resources/forms-public-forms.png)

A form is **External** when its Form type was set to "External" at creation. You can't change a form between External and Internal afterwards, see [Creating a form](https://flexie.io/resources/forms/creating-a-form#step-1-the-three-first-choices-you-cant-change-them-later).

## The URLs Flexie gives you

Every External form has a unique identifier and a small set of URLs built from it. You find these on the form's view page (`/forms/view/{id}`):

| URL                            | What it is                                                                                           |
| ------------------------------ | ---------------------------------------------------------------------------------------------------- |
| /form/{identifier}             | The **public form page**. Open this in any browser and you'll see the form ready to fill in.         |
| /form/push/{identifier}        | The **submit endpoint**. The form posts here when you click Submit.                                  |
| /form/upload/{identifier}      | The **file-upload endpoint**. Used internally when a submitter chooses files in a File Upload field. |
| /form/attachment/{hash}        | The **download endpoint**. Opens a previously uploaded file.                                         |
| /load-form.js?idf={identifier} | The **embed script**, see [Embedding](#embedding-the-form-on-your-website) below.                    |

You don't need to use any of these directly; they are all wired together. The two you'll share are the public form page (to send people directly to it) and the embed snippet (to put the form on your own site).

## Embedding the form on your website

The embed snippet is a single line. Open your form, copy the embed code, and paste it where you want the form to appear:

```html
<script src="https://your-flexie/load-form.js?idf=<your-form-identifier>"></script>

```

What happens when a visitor's browser hits a page with this snippet:

1. The script downloads from your Flexie instance.
2. It creates a `<div id="ff-{identifier}">` placeholder at that spot.
3. It loads the form's structure and renders the form into that placeholder.
4. When the user submits, the form posts to `/form/push/{identifier}` on your Flexie host.

You can place the snippet **anywhere** on your page: header, sidebar, inline in an article. It does not affect the rest of the page's layout beyond inserting its own container.

> If your website is on a different domain to your Flexie instance, the embed snippet's normal `<script src>` request and its form submission are _both_ permitted by browsers without extra setup, no CORS configuration is needed. CORS only matters when _your_ JavaScript posts directly to the submit URL, which the embed snippet doesn't do.

### Styling

The form ships with default styling that works on most sites. To restyle it:

* Use the **Accent colour** in form settings to match your brand.
* Add a **Custom JavaScript** block in form settings to inject scoped CSS or to hook into form events.

If you need a totally custom design, build the form on your own page and post directly to `/form/push/{identifier}` from your code, but you'll then be on your own for client-side validation.

## What the public form does when someone submits

When a visitor clicks Submit:

1. The form validates the entries in the browser (Required, Email format).
2. If a reCAPTCHA is configured, a score is fetched.
3. The form posts the JSON payload + any attachments to `/form/push/{identifier}`.
4. Flexie stores the submission, runs your workflow, and **waits up to 20 seconds** for the workflow to produce a response if one is requested. If the workflow doesn't respond, the form's default response (the Settings, Post-submit behaviour) is used.
5. The submitter sees the response: a message you wrote, a redirect to a URL, or a custom response computed by the workflow (see [Writing a custom response](https://flexie.io/resources/forms/forms-in-workflows#writing-a-custom-response-per-submission)).

The workflow listener that fires for an External form is **`virtual_workflow.form_submit`**, and the submission's field values appear in your workflow steps as `{{ __data.form_submission.<field key> }}`. See [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows#1-the-external-public-form-listener).

## Spam protection, Google reCAPTCHA v3

External forms can use **Google reCAPTCHA v3** to filter out abusive submissions. v3 is invisible: there is no checkbox or image puzzle. It scores each submission from `0.0` (almost certainly a bot) to `1.0` (almost certainly human) and Flexie rejects anything below **`0.7`**.

### To turn it on

1. **Get a reCAPTCHA v3 site key and secret key** from Google (`https://www.google.com/recaptcha/admin`). Choose **reCAPTCHA v3** (not v2), and register the domain(s) you'll embed the form on, including your Flexie host if visitors will see the form at `/form/{identifier}`.
2. **Open the form's Settings.**
3. Turn on **Add Google reCAPTCHA**.
4. Paste the **Site key** and the **Secret key**.
5. **Save and republish** the form.

From that point on, every submission is scored before the workflow runs. Submissions below the threshold are rejected with an error response and **never trigger the workflow**.

### When reCAPTCHA isn't enough

* It scores **automated** submissions; it doesn't stop a real human filling in rubbish.
* It needs JavaScript, so it doesn't help against headless submissions to `/form/push/{identifier}` direct.
* For high-risk forms (anything that auto-creates a record with permissions or triggers paid actions), pair reCAPTCHA with workflow-side checks. For example, look up whether the submitted email is on a known-bad list before creating the lead.

## File uploads, allowed types and limits

If a File Upload field is on your form, the user picks file(s) and they are sent up to Flexie when they submit.

### Allowed file types

The default allow-list is, broadly, **office documents, common images, and text**:

* **Documents**: `pdf`, `doc`, `docx`, `xls`, `xlsx`, `ppt`, `pptx`, `txt`, `csv`
* **Images**: `jpg`, `jpeg`, `png`, `gif`
* (Plus a handful more; your administrator can confirm the exact list for your account.)

Files outside the allow-list are rejected at upload time with an error to the submitter.

### Multiple files

A File Upload field can be set to **single file** or **multiple files** via the field's settings, see [Creating a form](https://flexie.io/resources/forms/creating-a-form#step-4-per-field-settings). With multiple files, the user can attach as many as the form's overall size budget allows.

### Image optimisation

If the form has **Optimise uploaded images** turned on, image attachments (`jpg` / `jpeg` / `png` / `gif`) are converted to a smaller web-friendly format on upload. This saves storage and makes downloads faster. The original file name is preserved in the submission record; only the storage format changes.

### Size limits

Per-file and per-form size limits are set by your account administrator and are ultimately bounded by your hosting configuration. If you need to accept very large files (e.g. multi-GB videos), ask your administrator to confirm what your current cap is. Most accounts use the default of "modest documents and images".

## Analytics

Add tracking IDs in the form's Settings to fire events on every submit:

* **Google Analytics tracking ID**, emits a form-submit event whenever someone successfully submits. Set **Anonymise IP** if you want GA to drop the last octet of the visitor's IP (GDPR best practice).
* **Facebook Pixel ID**, fires a `Lead` event whenever someone submits, so the conversion shows up in your Meta ads dashboard.

Both are optional and independent.

## GDPR and legal basis

External forms must declare a **legal basis** for processing the data they collect. You choose this in the form's Settings. Options include Consent, Contract, Legal obligation, Vital interests, Public task, Legitimate interests, and Pre-contractual measures. The chosen basis is recorded with every submission.

For consent-driven forms, add a **GDPR Consent** field type to the form itself (see [Creating a form](https://flexie.io/resources/forms/creating-a-form#data-fields)) and gate the **Submit** button on it being ticked.

## Private external forms (signed URLs)

If you want the form to be available _only_ via a time-limited, signed link (for example you've emailed a specific person an "update your details" form that should expire in 7 days):

1. Mark the form as **private** in its Settings.
2. Generate signed URLs using `signUrl(...)` in a Flexie Scripting expression. For example in an email template:  
```  
{% set link = signUrl("https://your-flexie/form/" ~ alias, 168) %}  
<a href="{{ link }}">Update your details</a>  
```  
(168 = 7 × 24 hours.)

A private form rejects any visit that doesn't carry a valid, in-date signature in the URL.

## What gets stored for each public submission

Every public submission writes a row that holds:

* The form it belongs to
* The submitted values (as JSON)
* Any uploaded attachments (their stored URL and original filename)
* The submitter's IP address, and an automatically-derived **country, region, city, ISP / organisation** from that IP
* The submitter's user agent (which browser they used)
* The exact submission timestamp

You view these on the form's **Submissions** page (`/forms/external/submissions/{formId}`), see [Submissions](https://flexie.io/resources/forms/submissions).

## Quick checklist before going live

1. Form is **published**.
2. **reCAPTCHA** keys are filled in (for any form accepting real public traffic).
3. The form has been **submitted at least once as a test**.
4. The workflow that fires on submit is **published** and was **tested with a real submission**.
5. The form's **default post-submit message or redirect** makes sense for the case where the workflow doesn't override it.
6. Analytics tracking IDs are in (if you want submit conversion tracking).
7. **Legal basis** is set.

## Next steps

* [Submissions](https://flexie.io/resources/forms/submissions): viewing what has come in.
* [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows): making the submission drive an automation, with a custom response.
* [Internal forms](https://flexie.io/resources/forms/internal-forms): the other flavour of form.

---

## Submissions

Source: https://flexie.io/resources/forms/submissions

# Submissions

Last updated 25 May 2026

![A submissions list with one row per submission and the detail view showing field values, attachments, and submitter metadata](https://flexie.io/image/resources/forms-submissions.png)

Every form submission is stored: the answers, who submitted, when, and which record (if any) it created or updated. Reading those submissions back happens in two places, the submissions screen for the human view and Flexie Scripting for the workflow view, with one syntax wrinkle (bracket notation for keys with spaces).

## Where submissions are stored

There are two storage areas, one for each broad flavour:

| Flavour                 | Stored in                  | View at                                                                                                   |
| ----------------------- | -------------------------- | --------------------------------------------------------------------------------------------------------- |
| External (public)       | External submissions table | /forms/external/submissions/{formId}                                                                      |
| Internal (entity-bound) | Internal submissions table | /forms/internal/submissions/{formId} (and /forms/internal/submissions/{formId}/{entityId} for one record) |
| Internal (virtual)      | Internal submissions table | /forms/internal/submissions/{formId}                                                                      |

Open the form's view page (`/forms/view/{id}`); there's a link to its submissions from there.

## What is stored for every submission

Every submission row holds:

* **The form** it belongs to.
* **The submitted values**, every field's value, keyed by the field's `key`, as JSON.
* **The attachments**, file metadata and the stored download URL for each uploaded file.
* **The submitter context**, who submitted (the user, for internal forms; the IP and user agent, for external forms).
* **The exact timestamp.**

External submissions additionally include **geo-enrichment** from the IP address: the visitor's **country, region, city, ISP / organisation**, so you can see where leads are coming from without extra setup.

## Viewing submissions

### From the form's page

Open the form (`/forms/view/{id}`) and follow the **Submissions** link in the sidebar. You'll see a paginated list with one row per submission, showing the most useful summary fields plus the submission date.

Click any row to see the full submitted values, attachments, and metadata.

### From a record's profile (entity-bound internal forms)

When you open a Contact, Deal, or Case profile, you can see the submissions **for this record** under each form's section. The same form on a different record only shows that record's submissions.

The URL is `/forms/internal/submissions/{formId}/{entityId}`, useful as a deep link.

### Searching, filtering, exporting

The Submissions list supports the same controls as other Flexie record lists: filter by date range, by submitted field values, sort by submitted-at, and export to CSV when you need the data outside Flexie.

## Deleting and re-submitting

You can delete an individual submission from its detail view. Deletion is **permanent**, there's no undo. Any workflow that already ran on that submission has already had its effect; deleting the row only removes the record of the submission, not the side effects (records created, messages sent).

There is no "re-submit" action. If you need to re-run the workflow against a saved submission's data, the simplest pattern is to look up the stored submission's fields and trigger your workflow manually.

## Reading a submission in a script

The submission's field values are exposed to your workflow steps via the `__data` namespace. The exact path depends on the flavour:

| Form flavour           | Read field xyz as                                  |
| ---------------------- | -------------------------------------------------- |
| External (public)      | {{ \_\_data.form\_submission.xyz }}                |
| Internal, entity-bound | {{ \_\_data.internal\_form\_submission.data.xyz }} |
| Internal, virtual      | {{ \_\_data.internal\_form\_submission.data.xyz }} |

Notice the **two differences**:

1. The **root key**: external uses `form_submission`; both internal flavours use `internal_form_submission`.
2. **External puts the fields directly under the root**; **internal nests them under a `data` sub-key** alongside metadata (`__submitted_from_user_id`).

This catches everybody once. If your token returns blank, this is the first place to check.

## Bracket notation for keys with spaces

A field's **key** comes from its label by default. So a field labelled _"First Name"_ probably has the key **`First Name`**, with a space and capital letters.

A space in a key means you **can't use the dot accessor**, because `__data.form_submission.First Name` is parsed by the scripting engine as a property called `First`, followed by a separate word `Name`, which won't read the field.

Use **bracket notation** with the exact key in quotes:

```
{# External public form #}
{{ __data.form_submission['First Name'] }}

{# Internal form #}
{{ __data.internal_form_submission.data['First Name'] }}

```

The same rule applies to any key with a hyphen, underscore-mixed-with-spaces, or any non-alphanumeric character.

> **The good habit** is to use bracket notation for _every_ form field access. It always works, it's explicit, and it future-proofs the script against someone renaming a field and accidentally putting a space in the key.

### A worked example, external submission

A form has three fields: _First Name_, _Email_, _Notes_. A visitor submits:

```
First Name = John
Email      = john@example.com
Notes      = Please call me back.

```

Your workflow step reads them like this:

```
Hello {{ __data.form_submission['First Name'] }},

We've received your message:
"{{ __data.form_submission.Notes }}"

We'll reply to {{ __data.form_submission.Email }} shortly.

```

Two of those use bracket notation; _Notes_ and _Email_ don't strictly need it (no spaces in the key), but using it consistently is safer.

### A worked example, entity-bound internal submission

The same fields, submitted from a team member on a Contact's profile:

```
Hi {{ first_name }},                    {# the contact's own first_name #}

{{ __data.internal_form_submission.__submitted_from_user_full_name }} just left
a note about you on {{ date(__data.internal_form_submission.date_added, "M j, Y") }}:

"{{ __data.internal_form_submission.data['Notes'] }}"

```

Notice: the **contact's** `first_name` is at the top level (it's the current record); the **submitter's** name comes from the `__submitted_from_user_*` metadata on the submission.

## Reading attached files

Attachments aren't exposed as scalar values; they live under a separate attachments slot on the submission. To get a list of uploaded files in a step (for example to forward them in an email):

```
{# External form #}
{% set files = __data.form_submission.attachments | default([]) %}
{% for f in files %}
  {{ f.originalName }} ({{ f.size }} bytes)
{% endfor %}

```

> The exact shape of `attachments` is a list of objects, each holding the stored URL, the original filename, the type, and the size. If you need to forward attachments to another system, the stored URL is the value to use.

## Guard against missing values

A submitter can leave optional fields blank, or a field can be removed from the form between submissions. Always guard:

```
{{ __data.form_submission['Notes'] | default("(no notes provided)") }}

{% if __data.form_submission['Email'] is defined and __data.form_submission['Email'] %}
  Send to {{ __data.form_submission['Email'] }}
{% endif %}

```

## Privacy and retention

Submissions can contain personal data (names, emails, sometimes far more). Two things to be aware of:

* **Default basis**: every external form must declare a legal basis for processing (see [Public forms: GDPR and legal basis](https://flexie.io/resources/forms/public-forms#gdpr-and-legal-basis)). That basis is recorded with each submission.
* **Retention**: there's no automatic deletion. Build a scheduled workflow if your retention policy requires you to purge old submissions, for example a monthly run that deletes External submissions older than two years on a closed form.

## Next steps

* [Forms in workflows](https://flexie.io/resources/forms/forms-in-workflows): the complete listener and action reference, with the response pattern.
* [Public forms](https://flexie.io/resources/forms/public-forms) / [Internal forms](https://flexie.io/resources/forms/internal-forms): the flavour-specific guides.

---

## Getting Started

Source: https://flexie.io/resources/getting-started/introduction

# Getting Started

Last updated 22 May 2026

![A Flexie onboarding setup checklist, three of five steps complete](https://flexie.io/image/resources/getting-started-introduction.png)

Flexie is one platform for running your business. Instead of separate apps for your customers, your sales, your invoices, and your messages, Flexie keeps it all in one connected place, with an AI workforce ready to do the busywork for you.

This guide takes you from "just signed up" to "up and running."

## Step 1: Set up your account

When you first sign in, take a few minutes to set up the basics:

* **Your business details:** name, logo, address, and currency. These appear on your quotes and invoices, so it is worth getting them right early.
* **Your branding:** add your logo so the documents you send look professional.
* **Your preferences:** date format, time zone, and language.

## Step 2: Invite your team

Flexie is built for teams. Invite the people you work with so everyone shares the same customers, deals, and inbox.

For each person you can set a **role**, which controls what they are allowed to see and do. A salesperson, a support agent, and a manager each get the access that fits their job. You can change this anytime.

Learn more: [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security).

## Step 3: Bring in your customers

Get your existing customers into Flexie so you can start working right away. You can add contacts and companies one at a time, or bring in a list of existing customers in bulk.

Learn more: [Contacts & Leads](https://flexie.io/resources/crm/contacts-and-leads).

## Step 4: Connect your communication

To send and receive messages inside Flexie, connect your channels:

* **Email:** connect your email account so messages send and arrive in Flexie.
* **SMS and WhatsApp:** set up text and WhatsApp messaging.

Once connected, every conversation lands in your shared inbox.

Learn more: [Inbox](https://flexie.io/resources/inbox/overview).

## Step 5: Find your way around

Here is the lay of the land. Each area of Flexie has its own place in the main menu:

## Step 6: Meet Flexie AI

Flexie's AI is more than a chat box. From day one you can ask it in plain words to find records, build a workflow, run a report, or update data, and it carries out the work for you. It is the fastest way to get comfortable.

Learn more: [Flexie AI](https://flexie.io/resources/ai/overview).

## A good first week

You do not have to do everything at once. Here is a simple path that gets real work running by the end of the week:

By the end of the week, Flexie is running real work for you.

## Next steps

* [Contacts & Leads](https://flexie.io/resources/crm/contacts-and-leads): start with your customers.
* [Deals & Pipelines](https://flexie.io/resources/crm/deals-and-pipelines): set up your sales process.
* [Flexie AI](https://flexie.io/resources/ai/overview): let the assistant speed everything up.

---

## Email Channel

Source: https://flexie.io/resources/inbox/email

# Email Channel

Last updated 26 May 2026

![An email conversation in the Flexie inbox with reply, reply all, and forward actions, plus the Incoming emails trigger wiring shown alongside](https://flexie.io/image/resources/inbox-email.png)

Each user connects their own mailbox to Flexie. From then on, email shows up in the shared inbox the moment it lands on the server, gets filed to the right customer automatically, and any incoming message can start a workflow.

In the inbox, a channel switcher lets you narrow the view to **Email**. Mailbox accounts are configured per user, each user connecting their own.

## What "the email channel" is

Each user connects one or more **mailbox accounts** to Flexie. From then on:

* New messages in those mailboxes appear in the shared inbox and on the customer's timeline.
* The user can compose, reply, and forward right from the inbox.
* Outbound mail is sent through the same account, so the recipient sees the message coming from the user's normal address.

A user can have multiple mailboxes (work address plus personal alias, or two team addresses). One is marked as the **default** for compose.

## Connecting a mailbox

Each user adds their own mailbox accounts from their user profile, using **Add Email Account**.

There are three "kinds" of accounts. The kind you pick changes which fields you fill in:

Google

Sign in with your Google account. The server settings are filled in automatically and locked.

Microsoft

Sign in with your Microsoft account. The server settings are filled in automatically and locked.

Other

Standard incoming/outgoing server connection. See the fields below.

### The form fields

| Field                          | What it is                                                                                                                                                                                              | Default for _Other_          |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- |
| **Account Name**               | Friendly label shown in the account picker                                                                                                                                                              | (yours)                      |
| **Choose your email provider** | Google / Microsoft / Other (button row). Picking Google or Microsoft prefills and locks the server settings below.                                                                                      | (none)                       |
| **IMAP server**                | Hostname of the incoming mail server                                                                                                                                                                    | (yours)                      |
| **IMAP port**                  | Incoming port                                                                                                                                                                                           | 993                          |
| **IMAP encryption**            | TLS / STARTTLS / SSL / None                                                                                                                                                                             | TLS                          |
| **SMTP server**                | Hostname of the outgoing mail server                                                                                                                                                                    | (yours)                      |
| **SMTP port**                  | Outgoing port                                                                                                                                                                                           | 587                          |
| **SMTP encryption**            | TLS / STARTTLS / SSL / None                                                                                                                                                                             | TLS                          |
| **Email Address**              | The address being connected                                                                                                                                                                             | (none)                       |
| **Email Password**             | Your mailbox password. Only used with _App Password_ or _User Password_ auth (see [Auth Type](#auth-type-xoauth2-app-password-user-password) below).                                                    | (none)                       |
| **Append Emails**              | Yes / No. When on, every email Flexie sends is also written to your server's _Sent_ folder, so it shows up in your normal mail clients. See [Append Emails, explained](#append-emails-explained) below. | (none)                       |
| **Default Email**              | Yes / No. If Yes, this account is the one used when you click **Compose** without picking an account first.                                                                                             | (none)                       |
| **Sync Calendar**              | Yes / No, pull calendar entries from this account into Flexie's calendar.                                                                                                                               | (none)                       |
| **Auth Type**                  | Which sign-in method Flexie uses to talk to your mailbox: **XOAUTH2**, **App Password**, or **User Password**. See [Auth Type](#auth-type-xoauth2-app-password-user-password) below.                    | XOAUTH2 for Google/Microsoft |

For Google or Microsoft, you'll be redirected through the standard sign-in flow; you don't fill in server settings or a password.

### Auth Type: XOAUTH2, App Password, User Password

Three options for the _Auth Type_ dropdown:

**XOAUTH2** is the secure OAuth flow used by Google Workspace and Microsoft Azure. When you sign in through Google or Microsoft, you go through their consent screen and Flexie gets a refresh token; no password is stored. This is the default (and recommended) option when you pick Google or Microsoft as the provider.

> Using XOAUTH2 across a whole organisation needs a one-time setup on the Google Workspace or Microsoft Azure side: a domain-wide app authorisation that lets Flexie read mailbox data on behalf of your users. The Flexie team can do this with you if you'd like a hand.

**App Password** is for _Other_ providers with two-factor authentication on. You generate a separate password from your mail provider's account settings, specifically for software clients like Flexie, and paste it into the **Email Password** field. The app password lets Flexie sign in without ever touching your normal login password.

**User Password** is your regular mailbox password. The least secure option, kept for older providers that don't offer an app-password flow. Avoid when you can.

### Append Emails, explained

Whether this needs to be on depends on your mail provider.

**Google and Microsoft handle Sent for you.** Their servers file a copy of every SMTP-sent message into the **Sent** folder automatically, so Flexie-sent emails already show up in Gmail, Outlook, and your phone's mail app alongside everything else. Leave **Append Emails** off for Google or Microsoft accounts; turning it on would just create duplicates.

**Smaller mail providers usually don't.** A mailbox that came with a web-hosting bundle (cPanel, Plesk, a generic IMAP server) typically treats SMTP and IMAP as separate services, with nothing copying outbound mail into Sent on its own. For those, set **Append Emails = Yes** and Flexie will write a copy of every outbound message into the **Sent** folder over IMAP, so your other mail clients still see what Flexie sent.

> Rule of thumb: **Google / Microsoft → off.** **Hosting-bundle email or any plain IMAP server → on.**

### Aliases (extra "From" addresses)

If your mailbox supports sending as several addresses (e.g. `sales@…` and `support@…` both delivered to the same inbox), add each one as an **alias** under the same account. Aliases let you pick the **From** address at compose time without setting up a second mailbox.

### After saving: first sync

Once the account is saved, Flexie does an initial backfill of recent history. From then on, new mail is **pushed the moment it comes in**: Flexie holds an open IMAP IDLE connection to the server, so messages land in the inbox within a second of the mail server receiving them. If the IDLE connection drops, a short fallback poll keeps the inbox current until the push channel reconnects. Sent items get copied back into the server's _Sent_ folder if **Append emails** is on.

> Adding an account adds a row to your **Email Accounts** list with a coloured status dot. Red means the last sync failed, usually wrong password, blocked sign-in, or a missing app password. Hover the dot for the last error.

## Mailbox folders

Each connected account exposes its folder tree (Inbox, Sent, Drafts, Trash, Spam, plus any custom folders you've created on the server). When you're in the email channel, the sidebar shows the folder tree of the selected account. Each folder has its own row count.

The shared inbox in the **Email** channel shows messages across **all your connected accounts' Inbox folders** combined, the view that matters most day-to-day. To look at _Sent_ or a custom folder, switch to that account's folder list from the sidebar.

## Sending email

### From the inbox

In the conversation view, three actions sit above the body:

* **Reply**: replies to the sender of the last message.
* **Reply All**: replies to the sender plus everyone in the To/CC list.
* **Forward**: composes a new message with the original quoted in.

The compose form has:

* **From**: your default account, or any of its aliases.
* **To**, **Cc**, **Bcc**: multi-value email pickers; entering a name auto-completes against your contacts, leads, and accounts.
* **Subject**: pre-filled with `Re:` / `Fwd:` for reply/forward.
* **Body**: rich HTML editor with images, links, formatting.
* **Attachments**: upload from your computer, attach a Flexie file (e.g. a quote or invoice PDF), or insert from any saved attachment.
* **Send-later schedule**: quick presets ("This afternoon", "Tomorrow morning", a custom date/time) or **Send now**.
* **Template**: paste a saved email template into the body.

### From a customer's page

Open a contact, lead, account, deal, or case → click **Compose** (or the email icon in the timeline) → the same form opens with **To** pre-filled to the customer's primary email.

This route also lets you attach a related document (e.g. a quote or invoice PDF) in one click.

### From a workflow

The workflow action **Send email** runs the same send path. See [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation).

## How incoming email is handled

Each connected mailbox holds an open **IMAP IDLE** channel to the server, so the moment a new message lands on the server, Flexie picks it up. The saved message keeps the sender, recipients, subject, body (both plain text and HTML), attachments, and read state.

### Grouping into conversations

Flexie follows the reply chain. A reply to an existing message stays in the same conversation, and replies you send through Flexie are set up so the recipient's email client also threads them with the original. When the reply chain isn't clear (e.g. a forwarded thread with the headers stripped), subject normalisation kicks in as a fallback: "Re:" and "Fwd:" prefixes are stripped for the grouping check.

### Auto-linking to a customer

While the message is being saved, Flexie looks for any record whose email field matches the sender's address (and the recipient's address for outbound copies). All matches get the message on their timeline. If nothing matches, the message still lands in the inbox and shows up under **Not linked**.

### Attachments

Files attached to a message can be either:

* **Standard attachments**: shown in the _Attachments_ row of the message.
* **Inline images**: embedded inside the HTML body (logos in a signature, screenshots pasted into the message).

The files themselves are stored in Flexie's attachments system and shown inline in the email view.

## Workflow triggers: email

Email gives you two triggers to choose from.

### Incoming emails

Use this when you want a workflow to react to **mail coming in**. It runs every time a new email lands in one of your connected mailboxes. You can narrow it down to a specific account, a specific folder, only unread mail, only replies, and so on.

**Form fields:**

* **Email account**: which connected account this trigger watches.
* **Folder(s)**: which folders within that account (typically _Inbox_).
* **Read emails**: _Any_ · _Read emails_ · _Unread_.
* **Reply emails**: _Any_ · _New_ (first message in a thread) · _Reply_ (a message that's responding to something).

**Runs against:** every customer record the email was linked to (the trigger runs once per matched record).

**What your workflow can use from the email.** Flexie exposes the incoming email's fields under `incoming_email` in your workflow data (usable from [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview)):

```twig
{{ __data.incoming_email.from_email }}
{{ __data.incoming_email.from_name }}
{{ __data.incoming_email.subject }}
{{ __data.incoming_email.text }}              {# plain-text body  #}
{{ __data.incoming_email.html }}              {# HTML body         #}
{{ __data.incoming_email.cc_emails[0] }}      {# array of strings  #}
{{ __data.incoming_email.cc_names[0] }}
{{ __data.incoming_email.date_received }}
{{ __data.incoming_email.has_inline_attachments }}
{{ __data.incoming_email.has_regular_attachments }}
{{ __data.incoming_email.all_attachments_count }}
{% for a in __data.incoming_email.all_attachments %}
  {{ a.name }} — {{ a.mime }} ({{ a.size }} bytes)
{% endfor %}

```

> **Use cases:** customer replies to an inactive thread → workflow re-opens the case · email from `billing@…` → auto-categorise as a billing query · email has an attachment named `*.signed.pdf` → mark the deal as **Contract signed**.

### Email opened

Use this when you want a workflow to react the moment **the recipient actually opens** an email you sent through Flexie. Opens are tracked by a tiny invisible image embedded in the message body.

**Runs against:** the customer the email was sent to.

This trigger is a "this happened" signal, useful for branching ("if the email was opened in 24h, do X; if not, follow up"). It doesn't make any extra fields available to the workflow on its own.

## The "Save email attachments to the customer" action

Closely tied to the email channel: a workflow action that takes the attachments off an inbound email and saves them against the linked customer's **Attachments** tab.

Typical recipe:

1. **Trigger:** Incoming emails, sender = `clients@…`.
2. **Action:** Save email attachments to the customer.
3. **Action:** Update field, `Last document received = {{ now() }}`.

After step 2, the linked contact, deal, or case has the attachment files in its own attachments collection. They survive even if the email is later deleted.

## Limits and gotchas

* **Big attachments**: there's a per-message attachment size cap; very large files will refuse to attach at send time with a clear error.
* **App passwords**: for _Other_ providers with two-factor authentication on, you'll need to generate an app password rather than entering your normal one. The provider's own help docs will tell you how.
* **Forwarded threads**: if the user clicks **Forward** rather than **Reply**, threading breaks intentionally (forward = new conversation with new recipients). The original is quoted in the body but the new message stands on its own.
* **The "Sent" folder** depends on **Append emails**. With it off, the server has no record of the message, only Flexie does. Keep it **on** if you want your sent items to show up in your phone's mail app.

## Next

* [SMS](https://flexie.io/resources/inbox/sms): the next channel.
* [Templates](https://flexie.io/resources/inbox/templates): saved replies, with variables.
* [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): the full trigger catalogue and the send actions.

---

## Overview

Source: https://flexie.io/resources/inbox/overview

# Overview

Last updated 26 May 2026

![A Flexie shared inbox interleaving email, SMS, and WhatsApp conversations into one timeline, each row linked to the customer it belongs to](https://flexie.io/image/resources/inbox-overview.png)

Email, SMS, and WhatsApp, all flowing into one view per user, with every message landing on the right customer's timeline automatically. Any incoming message can kick off a workflow.

Inside the inbox, a **channel switcher** lets you narrow the view to **Email**, **SMS**, or **WhatsApp**, or pick **All** to see every channel mixed into one timeline.

## What the shared inbox is

A single timeline that interleaves emails, text messages, and WhatsApp conversations into one list. Each row is the most recent message in a thread; clicking a row opens the full conversation in the channel's view.

The same conversation also appears on the **timeline of the customer it's linked to**, so opening a contact, lead, deal, account, or case shows every email, SMS, and WhatsApp exchanged with them, regardless of which channel each came in on.

## Channel accounts and who can use them

The inbox isn't a single global mailbox that the whole company shares. It's a per-user view that combines every **channel account** the user has been given access to. You add as many accounts as you need, and each account decides who can use it.

Email mailboxes

Each team member connects their own from their profile. A user's inbox shows the mailboxes they've connected, so personal correspondence stays personal.

SMS lines

Set up at platform settings. Each line has an **Access** list: all users, specific permission sets, user groups, or named users only. Anyone with access can send and receive on that line.

WhatsApp channels

Each paired number is a separate channel with the same kind of **Access** list. Pair as many numbers as you need (Sales, Support, a specific region) and grant the right team to each one.

So a sales SMS line might be shared with the whole sales team, a support WhatsApp number only with the support group, and a personal email mailbox only with the person who connected it. Each user's inbox is the union of whatever they've been granted, plus their own.

> "Shared" in _shared inbox_ means **shared across channels** for every user, and shared **across the team** for any account whose access list includes more than one person.

The icons mark the channel; the chip on the right shows the customer the message has been auto-linked to.

## The three channels at a glance

Email

Long-form back-and-forth: quotes, contracts, follow-ups, anything you already send by email. Replies stay together as one conversation, both in Flexie and in the recipient's email app.

SMS

Short, time-sensitive messages: reminders, confirmations, one-word replies. Fast, direct, and the customer doesn't need any app to receive them, just a phone with signal.

WhatsApp

The channel many of your customers already chat on every day. Send text, photos, voice notes, and PDFs, or run a full group chat with a customer's whole team.

Pick a channel from the channel switcher at the top of the inbox. The **All** view is the default: three channels interleaved in one list.

Each channel has its own setup, conventions, and workflow triggers. The channel-specific pages cover the detail:

* [Email](https://flexie.io/resources/inbox/email): connecting a mailbox, sending, threading, attachments, the inbound and "opened" workflow triggers.
* [SMS](https://flexie.io/resources/inbox/sms): adding an SMS line, sending, inbound, and the "received" / "delivered" workflow triggers.
* [WhatsApp](https://flexie.io/resources/inbox/whatsapp): adding a WhatsApp number via QR pairing, sending text and media, the inbound workflow trigger (including group chat fields).
* [Templates](https://flexie.io/resources/inbox/templates): email templates and SMS templates that also feed WhatsApp.
* [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): the full list of channel triggers and actions, plus what data each one makes available to your workflow.

## The filters above the list

Above the inbox list there's a filter pill:

| Filter         | Meaning                                            |
| -------------- | -------------------------------------------------- |
| **All**        | Everything                                         |
| **Seen**       | Messages already opened (by you)                   |
| **Unseen**     | New / unread                                       |
| **Linked**     | The message is auto-attached to a customer record  |
| **Not linked** | Couldn't be matched to a customer, needs attention |
| **Attachment** | Has at least one file attachment                   |

The filter combines with the channel selector. **Channel: SMS** plus **Filter: Unseen** shows just the unread SMS conversations.

## How messages are linked to customers

When an incoming message comes in, Flexie tries to attach it to one or more customer records automatically. The rule is per-channel:

| Channel      | Match by                                                                                                               |
| ------------ | ---------------------------------------------------------------------------------------------------------------------- |
| **Email**    | The sender's email address compared against any email field on contacts, leads, accounts, deals, cases, and users      |
| **SMS**      | The sender's phone number (in international format) compared against any phone/mobile field on the same set of records |
| **WhatsApp** | The sender's phone number (in international format) compared against the same phone/mobile fields                      |

A single message can link to **more than one record**. If the same email address belongs to a contact and a lead, both get linked, both get the message on their timeline. If nothing matches, the message still lands in the inbox but shows up under the **Not linked** filter so someone can attach it by hand.

> When a message links to a record, it also becomes a possible trigger for automations on that record's type. See [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation).

## How messages are grouped into conversations

Each channel uses its own grouping rule:

* **Email**: Flexie follows the reply chain. A reply to an existing message stays in the same thread; the recipient's email client sees it as a proper reply too.
* **SMS**: a conversation is the pair of phone numbers involved. The inbox row shows the latest message in that conversation; opening it shows the full history with that number.
* **WhatsApp**: for direct chats, a conversation is the pair of phone numbers (regardless of who messaged first). For group chats, a conversation is the group itself, and each message shows who sent it inside the group.

## What's covered in this section

1. [Email](https://flexie.io/resources/inbox/email): adding a mailbox, the compose flow, and the email triggers (**Incoming emails** and **Email opened**).
2. [SMS](https://flexie.io/resources/inbox/sms): connecting an SMS line, sending from the inbox or a customer's page, and the SMS triggers ("received" and "delivered").
3. [WhatsApp](https://flexie.io/resources/inbox/whatsapp): adding a WhatsApp number (QR pairing, access control, optional proxy), sending text and media, and the inbound trigger including group chats.
4. [Templates](https://flexie.io/resources/inbox/templates): saved templates for email and SMS, how variables work, and how templates feed both SMS _and_ WhatsApp compose.
5. [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): every channel trigger and action, with the data each one makes available to your workflow.

## Closely related

* [Telephony](https://flexie.io/resources/phone/overview): phone calls are the fourth channel that lands on the same customer timeline, with click-to-call from any phone field, recordings, and the **Completed call** workflow trigger.
* [Workflows](https://flexie.io/resources/workflows/overview): every incoming message is a potential workflow trigger; every outgoing message can be a workflow action.
* [Cases & support](https://flexie.io/resources/crm/cases-and-support): an inbox message becomes a support case in one click.
* [Contacts & leads](https://flexie.io/resources/crm/contacts-and-leads): the customer timeline is the same data this inbox shows, just sliced per-record.

---

## SMS Channel

Source: https://flexie.io/resources/inbox/sms

# SMS Channel

Last updated 26 May 2026

![An SMS conversation in the Flexie inbox with a customer replying YES, triggering a workflow that confirms the appointment](https://flexie.io/image/resources/inbox-sms.png)

A connected text-messaging line lets your team send and receive SMS straight from the inbox or from any customer's page. Incoming texts land in the inbox, link to the right customer automatically, and can trigger workflows the moment they come in.

A channel switcher in the inbox lets you narrow the view to SMS. The provider itself is configured once for the whole account by a system administrator.

## What "the SMS channel" is

A connected text-messaging line (or several). Outbound messages are sent through the configured provider; incoming messages come in from the provider and surface in the shared inbox alongside email and WhatsApp.

Once set up, SMS works the same way as email from a user's point of view: open a customer, click the SMS icon, type, send. The conversation lives in the inbox and on the customer's timeline; replies from the customer pop back into the inbox.

## Connecting an SMS line

Configuration is account-wide. Once set, every user with access can send and receive SMS through the line.

The form has these fields:

| Field                     | Meaning                                                                                                                                                                                                                                                                                       |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **SMS Provider**          | The SMS provider you're connecting to. Pick the one you have an account with. The fields below change to match.                                                                                                                                                                               |
| **Provider credentials**  | For each supported provider, a sub-form appears with the credentials your account needs (typically an account identifier, an auth key, and the phone numbers your account can send from).                                                                                                     |
| **Append Country Prefix** | (Optional) A default country prefix (+1, +44, +355, etc.) that Flexie will **automatically prepend to any outbound phone number that doesn't already include a country code**. Numbers that already start with a recognised prefix are left untouched. See _Handling messy phone data_ below. |
| **Access**                | Who can use the SMS channel: combinations of "all users", specific roles, user groups, or named users. The same model as everywhere else in Flexie.                                                                                                                                           |
| **Schedule-send presets** | Up to five quick-pick times for the **Send later** menu (e.g. "Tomorrow 9am", "Monday morning").                                                                                                                                                                                              |

After saving, **Test** the provider with a known phone number to confirm the credentials work. The test sends a single short message and reports back the provider's status.

### Handling messy phone data: Append Country Prefix

Real-world phone fields are messy. Some records have full international numbers like `+14155551212`; some have local numbers like `(415) 555-1212`, `0415 555 1212`, or just `4155551212`, whatever the operator typed when they captured the lead.

The **Append Country Prefix** setting is how you cope with that. Set it to the country you mostly do business in (e.g. `+1` for the US, `+44` for the UK, `+355` for Albania), and on every outbound message:

* A number that **already starts with a recognised country code** (for instance `+44 7700 900 123`) is sent as-is.
* A number that **doesn't have a country code** (`07700 900 123`, `(415) 555-1212`, `4155551212`) gets your configured prefix added automatically before it goes out.

It's the cheapest way to make a database with a mix of formats just work, without having to clean up every phone field by hand. The same prefix is also used when matching inbound numbers back to your records, so an inbound from `+447700900123` matches a contact stored as `07700 900 123`.

> Leave **Append Country Prefix** blank if your customer base spans many countries and every phone field is already stored in full international format. The setting prepends one prefix only; it can't guess which country a bare local number belongs to.

### How numbers look once sent

Outbound numbers go out to the provider in international format (starting with `+`, country code, then the local number, no spaces or dashes). So a customer record stored as `(415) 555-1212` with **Append Country Prefix** set to `+1` is sent as `+14155551212`. The same normalisation is used when matching inbound numbers to your records.

## Sending SMS

### From the inbox

In the SMS channel, the **Compose** button opens a small form:

| Field                          | What you fill in                                                                                          |
| ------------------------------ | --------------------------------------------------------------------------------------------------------- |
| **Recipient phone**            | The destination number (auto-complete searches by name across contacts, leads, and accounts)              |
| **From line**                  | Which of your connected lines to send through (if more than one)                                          |
| **Message**                    | The text body. Character counter shows length and segment count                                           |
| **Attach a quote/invoice PDF** | Optional. Attaches a short link to the document; the recipient gets a link they can tap to open the file. |
| **Send later**                 | Pick one of your saved presets, or a custom time                                                          |

### From a customer's page

The timeline view on contact, lead, account, deal, or case has an **SMS** action that pre-fills the recipient's phone field.

### From a workflow

The workflow action **Send SMS** lets you build automated outbound messages: appointment reminders, follow-ups, payment-due nudges. Form fields:

* **Message**: the SMS body, with [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) variables (e.g. `Hi {{ first_name }}, your invoice {{ invoices[0].name }} is due tomorrow.`).
* **Mobile field**: which field on the customer's record holds the phone number to send to (a phone/mobile field).
* **From line**: which connected line to send through.

See [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation) for the trigger-plus-action combinations.

## How incoming SMS is handled

When the provider receives a text addressed to one of your numbers, it notifies Flexie. Flexie then:

1. **Normalises the numbers** to international format.
2. **Saves the message**: the text, sender and recipient numbers, the provider's status (`queued` / `sent` / `delivered` / `failed`), and marks it as unread.
3. **Looks up** every record whose phone field matches the sender's number. The message appears on every matched record's timeline.
4. **Threads to a case**: if the same number was sent a message tagged with a case reference like `[FX-XXXXXXXX]`, the new inbound message is linked to that case automatically (so a customer texting back about support stays in the same case).
5. **Runs the "Incoming SMS" workflow trigger** on every matched record (see below).

If nothing matches the sender's number, the message still lands in the inbox and shows under the **Not linked** filter. Somebody on the team can attach it to a customer by hand from the conversation view.

### Delivery status updates

Most providers also report back when an outbound SMS has actually been delivered (or failed). When the status update comes in, Flexie updates the message's status and starts any workflows you've set up on the **SMS delivered** trigger.

## Workflow triggers: SMS

### Incoming SMS

Use this when you want a workflow to react to a **text message from a customer**. It runs every time a new SMS comes in and is matched to one of your records.

**Form fields:**

* **Text match**: an optional pattern matched (case-insensitively) against the message body. Patterns like `YES*` match any message starting with "yes"; `*opt out*` matches if "opt out" appears anywhere; leaving it blank runs the workflow on every message.

**Runs against:** every customer record the SMS was matched to (the trigger runs once per matched record).

**What your workflow can use from the SMS.** Flexie exposes the inbound message under `incoming_sms` in your workflow data:

```twig
{{ __data.incoming_sms.sender_number }}    {# +14155551212              #}
{{ __data.incoming_sms.to_number }}        {# the line that received it  #}
{{ __data.incoming_sms.text }}             {# the message body           #}
{{ __data.incoming_sms.date_received }}

```

> **Use cases:** customer texts "YES" to confirm an appointment → workflow marks the appointment as confirmed and sends a thank-you · customer texts "STOP" → workflow flips their _Allow SMS_ field to No.

### SMS delivered

Use this when you want a workflow to react the moment **an outbound SMS is confirmed delivered** by the provider, useful for "send a follow-up X minutes after the welcome SMS actually reaches the customer" flows.

**Form fields:**

* **Text match**: same pattern style as the "Incoming SMS" trigger, matched against the delivered text.

**What your workflow can use from the delivered SMS** (exposed under `delivered_sms`):

```twig
{{ __data.delivered_sms.text }}
{{ __data.delivered_sms.date_delivered }}

```

> **Use case:** "Send a follow-up workflow ten minutes after the welcome SMS was actually delivered". Pair "SMS delivered" with the **Wait** action.

## SMS templates

A library of saved messages, see [Templates](https://flexie.io/resources/inbox/templates). When composing an SMS, you can drop a template into the body in one click; when sending from a workflow, the **Send SMS** action's _Message_ field accepts the same template variables directly.

## Auto-case-threading (the `[FX-XXXXXXXX]` reference)

When a workflow or user sends an SMS that's tied to a **case**, Flexie appends a short reference token like `[FX-AB12CD34]` to the body. If the customer texts back from the same number, the inbound message is auto-attached to that case, so the whole back-and-forth stays in one case, even if the customer's first reply doesn't quote the original message.

The token is short and only appears when there's a case in scope; for plain marketing or transactional SMS, no reference is added.

## Limits and gotchas

* **Length and segments.** A single SMS holds up to 160 standard characters. Longer messages get split into multiple segments and the recipient's phone reassembles them. Emojis push the encoding into a different mode and drop the per-segment limit to **70 characters**. Flexie's compose form shows segment count live.
* **Inbound is best-effort.** Carriers occasionally delay messages by several minutes. Don't build workflows that depend on inbound SMS as a reliable real-time signal.
* **Unsubscribe (STOP).** Most providers auto-handle the "STOP" keyword at the carrier level, meaning the user gets stopped _before_ their reply reaches Flexie. Build an "Incoming SMS" trigger on "STOP" _and_ check the customer's "Allow SMS" field on send.
* **Multiple lines.** If you have several connected lines, "From line" on the compose form picks the one. In workflows, the **Send SMS** action has the same picker.
* **One country prefix only.** **Append Country Prefix** only adds _one_ country code, whichever you've configured. If your customers span several countries, the safest bet is to store every phone number in full international format (`+44…`, `+1…`, …) and leave the setting blank. The setting is for accounts that mostly do business in a single country and want to forgive operators who type local numbers.

## Next

* [WhatsApp](https://flexie.io/resources/inbox/whatsapp): the third channel; the same compose UI with media support.
* [Templates](https://flexie.io/resources/inbox/templates): SMS templates also feed WhatsApp compose.
* [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): the full trigger catalogue and the **Send SMS** action's form fields.

---

## Templates (Email & SMS)

Source: https://flexie.io/resources/inbox/templates

# Templates (Email & SMS)

Last updated 26 May 2026

![A saved email template with a Flexie Scripting variable in the subject, ready to be inserted into compose](https://flexie.io/image/resources/inbox-templates.png)

Saved messages with variables you drop into compose with one click. Email templates and SMS templates are separate libraries; the SMS library also feeds the WhatsApp compose form.

## Why templates

Three reasons you'll keep coming back to them:

1. **Speed**: a recurring reply ("Thanks for getting in touch, here's the next step…") takes one click rather than two minutes.
2. **Consistency**: everyone on the team sends the same wording, formatted the same way.
3. **Variables**: `{{ first_name }}`, `{{ invoices[0].total_incl_tax }}`, `{{ now("d M Y") }}`, written once, personalised on every send. The templating language is [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview).

Templates work the same way whether you're composing manually or sending from a [workflow action](https://flexie.io/resources/inbox/workflows-and-automation).

## Email templates

### Creating a template

The form fields:

| Field                        | What it does                                                                                                                          |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**                     | Internal label, shown in the template picker.                                                                                         |
| **Description**              | A note about when to use this template.                                                                                               |
| **Subject**                  | The email subject line, accepts variables.                                                                                            |
| **From address / From name** | Override the sender for emails using this template (leave blank to use the user's default mailbox).                                   |
| **Reply-to address**         | Override where replies go (e.g. a shared support address).                                                                            |
| **CC / BCC address**         | Default CC/BCC recipients.                                                                                                            |
| **Language**                 | Two-letter language code, used by the language-aware template picker.                                                                 |
| **Email type**               | _Template_ (used by users / workflows), _Broadcast_ (used for mass-send campaigns), or others depending on what's installed.          |
| **Template layout**          | The HTML wrapper layout: header, footer, branding.                                                                                    |
| **Custom HTML**              | The body, in HTML, with variables. Edit via the visual builder or the HTML editor.                                                    |
| **Plain text**               | An auto-generated plain-text fallback (you can override).                                                                             |
| **Record type**              | Which record type variables resolve against (lead, contact, deal, case, …). Determines what's in scope when the template is rendered. |
| **Track all links**          | Yes / No, wraps every link with a click-tracker so opens become measurable.                                                           |
| **Publish up / down**        | Optional date range during which this template is usable.                                                                             |
| **Access list**              | Who can use this template (combinations of all users / roles / groups / named users).                                                 |

### Variables in email templates

Wherever the template asks for text (subject, body, BCC, anywhere) you can use [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview):

```html
<p>Hi {{ first_name | default("there") }},</p>
<p>Your quote <strong>{{ quotes[0].name }}</strong> for
   {{ quotes[0].total_incl_tax | number_format(2) }} is attached.</p>
<p>It's valid until {{ quotes[0].valid_until | date("d M Y") }}.</p>

```

The "current record" is whatever the template is being rendered against: the contact you clicked **Compose** from, the lead a workflow is running on, etc. Related records are arrays (`contacts[0]`, `accounts[0]`, `quotes[0]`, …). See [Flexie Scripting → Language basics](https://flexie.io/resources/flexie-scripting/language-basics) for the full rules.

### Tracking: opens and clicks

If **Track all links** is on:

* Every link in the email is rewritten to go through Flexie's click-tracker first, then on to the original URL.
* A tiny invisible image is inserted in the HTML for **open tracking**.

Each click is logged on the recipient's record; opens become the trigger for the [Email opened workflow trigger](https://flexie.io/resources/inbox/email#email-opened). Open any email template to see its per-message **Stats** (opens, clicks, delivery counts) and its **Clicks** breakdown (which links were clicked, by whom, when).

### A/B testing

For broadcast-type emails, the template form has a **Variant** tab. You can:

* Define one or more variant subjects/bodies/HTML.
* Set the split weight (e.g. A/B 50/50, or A/B/C/D).
* Pick a winner by open-rate or click-rate after a chosen window.

### Personal signatures vs templates

A user's email signature is part of their **mailbox account** profile (set on the mailbox itself), not a template. Signatures are appended to the body of every outbound email; templates are inserted into the body. Both work together: your template provides the message; your signature finishes it.

## SMS templates

### Creating an SMS template

The form fields:

| Field           | What it does                                                       |
| --------------- | ------------------------------------------------------------------ |
| **Name**        | Internal label, shown in the template picker.                      |
| **Text**        | The message body, accepts variables.                               |
| **Record type** | Which record type variables resolve against (lead, contact, etc.). |
| **Category**    | Optional folder for grouping templates.                            |
| **Owner**       | Who created it (visible in the list).                              |
| **Access list** | Who can use this template.                                         |

### Variables: same rules as email

```
Hi {{ first_name }}, your appointment is on
{{ next_appointment | date("D d M, H:i") }} at {{ accounts[0].address }}.
Reply YES to confirm, NO to reschedule.

```

Be mindful of length. The compose form shows live character plus segment counts; templates with long variable expansions (e.g. a full street address) can push a one-segment template into three. Test the template against a real customer before saving.

### SMS templates feed WhatsApp compose

Both the SMS compose form and the WhatsApp compose form share the **SMS template** picker. A "We received your invoice" template you wrote for SMS is also available when replying on WhatsApp. There's no separate "WhatsApp template" library today; if you need a WhatsApp-only template, either prefix it (`[WA]`) or limit its access list to people who only work in WhatsApp.

> The other direction also matters: WhatsApp lets you attach media, while SMS can only attach a link. If your template assumes an image is attached, that works in WhatsApp but not in SMS. Keep the template's text self-contained, and add media on the compose form for WhatsApp.

## Using a template

### From compose

In the email or SMS compose form, **Templates** opens a picker. You'll see templates filtered by:

* the current record type (only templates whose **Record type** matches),
* your access (templates you're allowed to use),
* your language preference (when the template has a **Language** set).

Click a template → its content is inserted into the compose body (replacing or appending depending on the picker). Variables aren't expanded until **Send**, that way you can edit the populated text first.

### From a workflow

The **Send email** workflow action has a **Template** picker, pick one, and the action uses its subject, body, from/reply-to addresses. The **Send SMS** and **Send WhatsApp** actions accept the SMS template via the same picker.

You can still override individual fields (subject, body, recipient) on the action; the template gives you a starting point.

## Gotchas

* **A template set to the wrong record type won't show up.** If your template's **Record type** is _Lead_ and you're composing from a _Contact_'s page, it won't appear in the picker. Either change it to the right record type, or duplicate it.
* **Variables on send-from-inbox.** When you compose from the inbox (without picking a customer first), variables that reference customer fields render as blanks. Compose from a customer's page if you want variables to resolve.
* **The "language" field is opt-in.** Setting it filters the picker for users whose preference matches. Leaving it blank means the template shows up for everyone, usually what you want.
* **CC/BCC at the template level.** These apply to _every_ send from the template. Don't put a personal address here; use the **Reply-to** field for a shared support inbox instead.
* **Tracking only works for HTML sends.** A plain-text-only email doesn't carry click trackers or open pixels.

## Next

* [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): using templates from the send-message workflow actions.
* [Flexie Scripting → Language basics](https://flexie.io/resources/flexie-scripting/language-basics): the variables you can use inside the template body.

---

## WhatsApp Channel

Source: https://flexie.io/resources/inbox/whatsapp

# WhatsApp Channel

Last updated 26 May 2026

![A WhatsApp number being paired to Flexie via QR code, with the inbox showing incoming text and media messages from individual chats and groups](https://flexie.io/image/resources/inbox-whatsapp.png)

Pair a WhatsApp number to Flexie and your team can chat with customers (text, photos, voice notes, PDFs, even group chats) from the same inbox they use for email and SMS. Inbound messages link to the right customer and can trigger workflows. In the inbox, a channel switcher lets you narrow the view to **WhatsApp**.

## What "the WhatsApp channel" is

A WhatsApp number you've **paired** to Flexie. After pairing, messages sent to that number show up in the shared inbox; you can reply with text, images, audio, documents, and attached PDFs (e.g. quotes and invoices). Group chats are supported. The inbox shows them with the group name and each message's sender.

You can connect more than one number. Each one is a separate **channel**; access to each channel can be granted to everyone, by role, by group, or by named users.

## Adding a WhatsApp number (QR pairing)

**Add WhatsApp number** opens the provision form:

| Field                     | Required                  | What it is                                                                                                                                                                                                                                                                       |
| ------------------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Phone number**          | Yes                       | The WhatsApp number being attached, in international format (+14302028897).                                                                                                                                                                                                      |
| **Display name**          | Optional                  | A label shown in the channel picker (e.g. _"Sales"_, _"Support"_).                                                                                                                                                                                                               |
| **Append Country Prefix** | Optional                  | A default country prefix (+44, +1, +355, …) automatically added to outbound numbers that don't already include a country code. Same rule as the SMS line, see [Handling messy phone data](https://flexie.io/resources/inbox/sms#handling-messy-phone-data-append-country-prefix) on the SMS page. |
| **Access**                | Yes (default _All users_) | Who can see and send through this channel: all users / specific permission sets / user groups / named users.                                                                                                                                                                     |

**Submit** → Flexie creates the channel in a _pending_ state and shows a **QR code**. From the phone holding the WhatsApp account, open WhatsApp → Settings → Linked Devices → Link a Device → scan the QR. Within a few seconds the channel flips to _connected_ and the QR disappears.

The QR is single-use; if it expires before you scan, the **Refresh QR** button generates a new one.

### Channel statuses

A channel sits in one of four states; you can see it on the channels list and at the top of the channel's inbox.

Pending

Provisioned but not yet paired. Waiting for the QR to be scanned.

Connected

Live. Inbound messages are flowing; outbound sends through this number.

Disconnected

The phone signed the device out, or the device hasn't checked in for a long while. Reconnect from the channel page.

Error

A persistent error. Hover the status for the last error message. Logout, reconnect, or, in extreme cases, delete and re-provision.

### Channel management actions

From the channels list, each channel offers:

* **Check status**: current connection state and last activity.
* **Refresh QR**: generate a new pairing code (during initial pairing or after a logout).
* **Edit**: rename the channel, change the access list.
* **Logout**: sign the device out cleanly (the channel stops sending and receiving; can be re-paired later).
* **Reconnect**: re-pair after a logout.
* **Delete**: remove the channel entirely.

## Sending WhatsApp messages

### From the inbox

In the WhatsApp channel, **Compose**:

| Field                          | What it is                                                                                  |
| ------------------------------ | ------------------------------------------------------------------------------------------- |
| **From channel**               | Which of your connected numbers to send through (if more than one is accessible to you)     |
| **Recipient phone**            | The destination number. Auto-complete searches by name across contacts, leads, and accounts |
| **Message**                    | The text body                                                                               |
| **Attachment**                 | Optional. Image (JPG/PNG), audio (OGG/MP3), document (PDF, DOCX, …)                         |
| **Attach a quote/invoice PDF** | Optional. One-click attach of a generated business document                                 |

### From a customer's page

The timeline view has a **WhatsApp** action that pre-fills the recipient.

### From a workflow

The workflow action **Send WhatsApp** mirrors the **Send SMS** action; see [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation).

> **No cold WhatsApp from workflows.** WhatsApp is a conversational channel, not a marketing one. Per WhatsApp / Meta policy, the **Send WhatsApp** action only succeeds when the customer has **recently messaged your channel**, they have to start the conversation first. Sends to anyone outside that recent window will be rejected. Once they message you, you can reply freely from automation. This isn't a Flexie limit; it's how WhatsApp Business works, and it's there to prevent spam.

### Group chats

When you reply inside a WhatsApp group conversation, the message is sent to the group (not to individual members). The compose form recognises a group thread and addresses the group automatically.

## How incoming WhatsApp is handled

When a customer messages your WhatsApp number, the message lands in your inbox seconds later. Flexie attaches it to the right customer automatically by matching the sender's phone number against your contacts, leads, accounts, deals, and cases. For group chats, the message links by the group identifier instead, so you can build workflows on a whole group (e.g. a customer support team) rather than a single contact.

Media (images, voice notes, documents, stickers) is pulled in alongside the message and previewed directly from the conversation view. Once a message is linked to a record, the **Incoming WhatsApp** workflow trigger runs on every matched record (see below).

## Workflow trigger: Incoming WhatsApp

Use this when you want a workflow to react to a **WhatsApp message from a customer**. It runs every time a new incoming message comes in and is matched to one of your records.

**Form fields:**

* **Message text**: optional pattern match (case-insensitive) against the message body. `YES*` matches "yes please", `*receipt*` matches any message containing "receipt", and leaving it blank runs the workflow on every message.

The form also shows a **Last 10 inbound messages** panel below the field so you can craft the pattern against real examples.

**What your workflow can use from the message** (exposed under `incoming_whatsapp`):

```twig
{{ __data.incoming_whatsapp.from_number }}         {# +14155551212        #}
{{ __data.incoming_whatsapp.to_number }}           {# your channel's #    #}
{{ __data.incoming_whatsapp.text }}                {# the message body    #}
{{ __data.incoming_whatsapp.message_type }}        {# "text" or "media"   #}
{{ __data.incoming_whatsapp.direction }}           {# "inbound"           #}
{{ __data.incoming_whatsapp.whatsapp_message_id }}
{{ __data.incoming_whatsapp.is_group }}            {# true / false        #}
{{ __data.incoming_whatsapp.display_name }}        {# sender's WA name    #}
{{ __data.incoming_whatsapp.date_received }}

```

And for **group messages only** (when `is_group` is true):

```twig
{{ __data.incoming_whatsapp.group_jid }}
{{ __data.incoming_whatsapp.group_name }}
{{ __data.incoming_whatsapp.participant }}        {# the in-group sender            #}
{{ __data.incoming_whatsapp.participant_jid }}    {# their WhatsApp identifier      #}

```

> **Use cases:** customer sends "INVOICE" → workflow finds their latest invoice, generates a fresh PDF, replies with the PDF attached · customer sends an image → workflow saves the image to the deal's attachments and notifies the salesperson.

### WhatsApp delivery confirmations: not yet available

A workflow trigger for "WhatsApp message delivered" isn't available in the current build. Use **Incoming WhatsApp** plus a **Wait** action if you need approximate "after delivery" timing.

## Limits and gotchas

* **No spam, ever.** WhatsApp is a conversational channel, not a marketing one. You cannot send automatic messages to people you don't have a **recent conversation** with, the customer has to message your channel first. If a workflow tries to **Send WhatsApp** to anyone outside that recent window, the send will fail. This is WhatsApp / Meta's policy and terms; the only safe pattern is **customer messages you → workflow replies**.
* **One device per number on WhatsApp side.** Pairing this device replaces any existing linked device. Existing chats stay on the phone; new incoming messages flow into Flexie.
* **The phone must stay connected.** If the paired phone is offline for too long, WhatsApp signs the device out; the channel flips to _Disconnected_ and inbound stops. Bring the phone back online and reconnect.
* **Groups vs DMs in the auto-link.** Direct messages link to records via the sender's phone. Group messages link via the group's identifier, so you can build a workflow on a _group_ (e.g. a customer support group) rather than a single contact.
* **Media size.** Each attachment has a per-message size cap (typically 100 MB); larger files are rejected before they reach Flexie.

## Next

* [Templates](https://flexie.io/resources/inbox/templates): saved messages with variables. The same SMS-template library feeds WhatsApp compose.
* [Workflows & automation](https://flexie.io/resources/inbox/workflows-and-automation): the WhatsApp trigger in the full catalogue, plus the **Send WhatsApp** action.

---

## Inbox in Workflows

Source: https://flexie.io/resources/inbox/workflows-and-automation

# Inbox in Workflows

Last updated 26 May 2026

![An inbound message on the left triggering a workflow that sends a reply on the right, with the workflow data payload shown in the middle](https://flexie.io/image/resources/inbox-workflows-and-automation.png)

Every channel can be a workflow **trigger** (a message came in) and a workflow **action** (send a message). Most automation in the communication area lives in that loop, a message in, a workflow run, a message back out.

For workflow fundamentals (building, runtime, parallel branches, passing data) see [Workflows (in depth)](https://flexie.io/resources/workflows/overview).

## At a glance

A workflow can start with a message **coming in** (a trigger) and respond with a message **going out** (an action). Most automation in the communication area lives in that loop.

## Triggers: full catalogue

| Trigger               | Runs when                                                                                                | Data your workflow can read |
| --------------------- | -------------------------------------------------------------------------------------------------------- | --------------------------- |
| **Incoming emails**   | Inbound email matched to a record. Filter by account, folder, read/unread state, and new-vs-reply.       | incoming\_email             |
| **Email opened**      | A previously-sent email is opened by the recipient.                                                      | (no extra data)             |
| **Incoming SMS**      | Inbound SMS matched to a record. Optional text pattern (YES\*, \*opt out\*, etc.).                       | incoming\_sms               |
| **SMS delivered**     | An outbound SMS is reported delivered by the provider. Useful for "X minutes after delivery" follow-ups. | delivered\_sms              |
| **Incoming WhatsApp** | Inbound WhatsApp matched to a record. Includes group fields when the message is from a group chat.       | incoming\_whatsapp          |

> A trigger "runs once per matched record". If an inbound message links to a contact _and_ a lead, the workflows on both record types run independently. See [Workflows → Triggers and sources](https://flexie.io/resources/workflows/triggers-and-sources).

### What's in each data bundle

Each trigger exposes the message's fields under a name in your workflow data. Use them anywhere [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) is accepted: message bodies, subjects, decisions, field updates.

#### `incoming_email`

```twig
{{ __data.incoming_email.from_email }}
{{ __data.incoming_email.from_name }}
{{ __data.incoming_email.subject }}
{{ __data.incoming_email.text }}            {# plain-text body  #}
{{ __data.incoming_email.html }}            {# HTML body         #}
{{ __data.incoming_email.cc_emails }}       {# array of strings  #}
{{ __data.incoming_email.cc_names }}        {# array of strings  #}
{{ __data.incoming_email.date_received }}
{{ __data.incoming_email.has_inline_attachments }}
{{ __data.incoming_email.has_regular_attachments }}
{{ __data.incoming_email.all_attachments_count }}
{{ __data.incoming_email.all_attachments }} {# array of {name, attachment_type, mime, size} #}

```

#### `incoming_sms`

```twig
{{ __data.incoming_sms.sender_number }}  {# +14155551212 #}
{{ __data.incoming_sms.to_number }}      {# your line    #}
{{ __data.incoming_sms.text }}
{{ __data.incoming_sms.date_received }}

```

#### `delivered_sms`

```twig
{{ __data.delivered_sms.text }}
{{ __data.delivered_sms.date_delivered }}

```

#### `incoming_whatsapp`

```twig
{{ __data.incoming_whatsapp.from_number }}
{{ __data.incoming_whatsapp.to_number }}
{{ __data.incoming_whatsapp.text }}
{{ __data.incoming_whatsapp.message_type }}        {# "text" or "media"   #}
{{ __data.incoming_whatsapp.direction }}           {# always "inbound"    #}
{{ __data.incoming_whatsapp.whatsapp_message_id }}
{{ __data.incoming_whatsapp.is_group }}
{{ __data.incoming_whatsapp.display_name }}
{{ __data.incoming_whatsapp.date_received }}

{# only when is_group is true: #}
{{ __data.incoming_whatsapp.group_jid }}
{{ __data.incoming_whatsapp.group_name }}
{{ __data.incoming_whatsapp.participant }}
{{ __data.incoming_whatsapp.participant_jid }}

```

See [Workflows → Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps) for the broader `__data` model.

## Actions: full catalogue

| Action                                     | What it does                                                                |
| ------------------------------------------ | --------------------------------------------------------------------------- |
| **Send email**                             | Send an email from a template or an inline subject/body to the record.      |
| **Send notification email**                | Send a notification email (to staff or a fixed address).                    |
| **Send SMS**                               | Send SMS to the record.                                                     |
| **Send WhatsApp**                          | Send WhatsApp to the record (only available when WhatsApp is enabled).      |
| **Save email attachments to the customer** | Save inbound-email attachments against the linked record's attachments tab. |

### Send email

Form fields:

* **Email template**: pick a saved [email template](https://flexie.io/resources/inbox/templates), or inline a one-off subject and body.
* **To**: usually the record's primary email field, but you can override with another field or a literal.
* **CC / BCC**: optional.
* **From address / Reply-to**: overrides the template's defaults.
* **Attach a file**: optional; you can attach a generated PDF (quote, invoice) by name.

Variables resolve against the record the workflow is running on, just like in compose.

### Send SMS

Form fields:

* **Message**: text body with variables.
* **Mobile field**: which field on the record holds the destination phone (a phone/mobile field).
* **From line**: which connected SMS line to send through.

### Send WhatsApp

Form fields:

* **Message**: text body with variables.
* **Mobile field**: phone field to send to.
* **Channel**: which connected WhatsApp number to send through.

**Constraint:** the recipient must have an **existing inbound message** on the chosen channel. WhatsApp's session-window model forbids cold outbound to a brand-new number, the action enforces this on its side.

### Save email attachments to the customer

Form fields:

* **Attachment filter**: optional name / file-type filter (e.g. `*.pdf` to copy only PDFs).
* **Attachment categories**: where to file the copies in the record's attachments collection.

Most often used right after an "Incoming emails" trigger to file inbound documents.

## End-to-end recipes

### 1\. Customer replies "STOP" → opt them out of SMS

### 2\. Incoming contract email → file the PDF on the deal

### 3\. WhatsApp "INVOICE" → reply with the latest invoice PDF

### 4\. Email open within 24 h → keep cadence, otherwise follow up

### 5\. Customer texts back about an open case → keep it in the same case

This one's **automatic**, no workflow needed. When you reply on a case via SMS, Flexie inserts a short reference token (`[FX-XXXXXXXX]`) into the outbound text. If the customer replies from the same number, the incoming message attaches itself to the same case. The case page shows the full back-and-forth as one thread.

See [SMS → Auto-case-threading](https://flexie.io/resources/inbox/sms#auto-case-threading-the-fx-xxxxxxxx-reference).

## The `__data` shape, in context

The `__data` namespace is built up step by step as a workflow runs. For communications:

```twig
{{ __data.incoming_email.subject }}     {# only if triggered by "Incoming emails"      #}
{{ __data.incoming_sms.text }}          {# only if triggered by "Incoming SMS"         #}
{{ __data.incoming_whatsapp.text }}     {# only if triggered by "Incoming WhatsApp"    #}
{{ __data.delivered_sms.text }}         {# only if triggered by "SMS delivered"        #}

{{ first_name }}                        {# always — the current record's field         #}
{{ contacts[0].first_name }}            {# always — related record, even on mail flows #}

```

Use the trigger-specific name when you need data from the message that started the workflow; use the top-level record fields for everything else.

## When a trigger doesn't run (debug checklist)

In roughly increasing difficulty:

1. **Is the workflow published?** Unpublished workflows don't run at all.
2. **Is the trigger configured for the right record type?** An "Incoming SMS" trigger on _Contact_ won't run when the SMS links only to a _Lead_. Either add the trigger for both record types, or change the record-type selection on the workflow.
3. **Did the inbound message link to any customer?** Check the inbox under the **Not linked** filter. No link → no customer → no trigger.
4. **Does the text match?** Patterns are case-insensitive but require literal `*`/`?` wildcards. `YES` doesn't match `"Yes please"`. Use `YES*`.
5. **For email:** does the trigger's _account + folder + read state + new/reply_ combination match the actual message?
6. **For WhatsApp:** is WhatsApp enabled for this account? The "Incoming WhatsApp" trigger only appears in the picker when WhatsApp is on.

Open the workflow's **History** tab to see whether the trigger ran but the next action errored, or whether the trigger itself never ran in the first place.

## Next

* [Workflows (in depth)](https://flexie.io/resources/workflows/overview): the canvas, triggers, actions, decisions, async vs sync, the tree.
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): the language used in template bodies, message bodies, and `__data` expressions.
* [Inbox overview](https://flexie.io/resources/inbox/overview): the shared inbox concept, filters, channel mix.

---

## Integrations & Developer Access

Source: https://flexie.io/resources/integrations/integrations-and-api

# Integrations & Developer Access

Last updated 23 May 2026

![Flexie in the centre, connected to other tools, a developer app, and an outside AI assistant through secure, controlled channels](https://flexie.io/image/resources/integrations-integrations-and-api.png)

Flexie is built to work with the rest of your software. It exchanges information both ways with the other tools you use, and it offers a secure, controlled door for developers and AI assistants to work with your Flexie data. This page is written for non-technical readers. Where a developer needs to get involved, that is noted clearly.

> **Need to receive data from another system right now?** Flexie's [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview) let you create a secure URL that an outside system can send data to, triggering a workflow. Often that is all the "integration" you need, with no code on the Flexie side.

## Connecting Flexie to your other tools

Your business probably runs on more than one piece of software. Flexie can keep in step with the others by exchanging information on its own:

* **Flexie tells other systems what is happening.** When something happens in Flexie, a new customer, a paid invoice, a won deal, Flexie can notify another system straight away.
* **Other systems send information into Flexie.** A website, a mobile app, or a partner system can push information into Flexie the same way, often through a [Dynamic Endpoint](https://flexie.io/resources/dynamic-endpoints/overview) that turns the incoming request into a workflow.

The result is that your tools stay in sync without anyone copying data from one screen to another by hand.

## Developer access

If you have a website, a mobile app, or a partner system that needs to work directly with your Flexie data, Flexie provides a secure way for developers to connect them.

Your technical team or a software partner can build the exact connection you need. You stay in control: you decide what each connection is allowed to do, and you can review or switch off any connection at any time.

## Connecting outside AI assistants to Flexie

AI assistants are quickly becoming part of how teams work, and Flexie is ready for them. You can safely open Flexie's capabilities to an outside AI assistant so it can work with your Flexie data on your behalf, looking up customers, pulling reports, and triggering automations. This uses the open industry standard for connecting AI assistants to business software, so the assistants your team already uses can plug straight in.

This is in addition to Flexie's own built-in AI workforce. See [Flexie AI](https://flexie.io/resources/ai/overview).

## Security and control

Every connection to Flexie, whether it is another tool, a developer's app, or an AI assistant, is protected:

* A connection only gets the access you grant it.
* Every request is checked against your permission rules.
* Anything important still asks for approval before it happens.
* You can see what is connected and switch off any connection at any time.

Opening Flexie up never means giving up control. See [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security).

## You may not need an integration at all

Because Flexie already covers sales, billing, communication, and support in one platform, much of what people use integrations for happens **inside** Flexie. Before reaching for an integration, check whether [Workflow Automation](https://flexie.io/resources/workflows/overview) already does the job, it usually does.

## Just ask Flexie AI

* "When a deal is won here, post a message to our team chat."
* "When a payment lands in our accounting tool, mark the matching invoice paid in Flexie."
* "Set up an endpoint our website can call to create a lead."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview): the no-code door into Flexie.
* [Flexie AI](https://flexie.io/resources/ai/overview): Flexie's own AI workforce.
* [Workflow Automation](https://flexie.io/resources/workflows/overview): your built-in "integration" for connecting everything inside Flexie.
* [Accounts, Teams & Security](https://flexie.io/resources/security/accounts-and-security): control who and what has access.

---

## Call Logs & Timeline

Source: https://flexie.io/resources/phone/call-logs-and-timeline

# Call Logs & Timeline

Last updated 26 May 2026

![A Flexie customer timeline interleaving phone calls, emails, SMS, WhatsApp, and notes, with a recording playback control on each call event](https://flexie.io/image/resources/phone-call-logs-and-timeline.png)

Every completed call leaves a record behind: who spoke, for how long, the recording if there is one, and a link to the customer it belongs to. The same record powers both the call-history list and the per-customer timeline.

On a customer's timeline, every call linked to that customer appears interleaved with email, SMS, WhatsApp, notes, and other events.

## What's in a call record

Each completed call leaves behind a record that holds:

| Field                | What it holds                                                                                  |
| -------------------- | ---------------------------------------------------------------------------------------------- |
| **Direction**        | Incoming or outgoing.                                                                          |
| **From / To**        | The two phone numbers in international format.                                                 |
| **Started at**       | When the call began.                                                                           |
| **Duration**         | Talk time after answer.                                                                        |
| **Outcome**          | Answered, Busy, No answer, Cancelled by caller, Declined, Failed. See the outcomes list below. |
| **Recording**        | A link to the recording (if recording is on for the channel).                                  |
| **Agent**            | The user who handled the call.                                                                 |
| **Linked customers** | The records this call has been attached to.                                                    |

### Call outcomes

The same outcome labels apply to both channels:

| Outcome                 | Meaning                                                 |
| ----------------------- | ------------------------------------------------------- |
| **Answered**            | The other side picked up; talk time was recorded.       |
| **Ringing**             | The call is still ringing (only visible on live calls). |
| **Busy**                | The other side was on another call.                     |
| **No answer**           | Rang through without being picked up.                   |
| **Cancelled by caller** | The caller hung up before the callee picked up.         |
| **Declined**            | The callee actively rejected the call.                  |
| **Failed**              | Network or routing failure, couldn't complete.          |

## How call records link to customers

Both channels run the same matching rule at the moment a call ends:

1. **Normalise** the other side's number to international format.
2. **Search every phone field** across leads, contacts, accounts, deals, cases, and users.
3. **For every match**, link the call to that record.

Concretely:

* Outbound to `+14155551212` matches a Contact's _Mobile_ field, so the call is linked to the contact (and to its account or open deals, if those records reference the same person).
* Incoming from `+14155551212` matches a Lead's _Phone_ field, so the call is linked to that lead.
* If `+14155551212` matches both a contact _and_ a separate lead, both get linked. The call appears on both timelines.
* If nothing matches, the call is logged but not linked. It still shows in **Call logs**; it just doesn't have a customer.

> Adding a phone field to **every** record type that might own the number (Contact, Lead, Account) is what makes the cross-record linking work. See [Custom records & fields](https://flexie.io/resources/customization/custom-records-and-fields) for the field types.

## Recordings

Recording is opt-in. On Twilio, the **Record calls** flag on the account turns it on for every call placed through that account. On a self-hosted PBX, recording is configured on the PBX itself, Flexie just stores the link the PBX hands back.

**Where the file lives:**

* **Twilio**: on Twilio's servers. The link in Flexie streams the recording directly from there.
* **Self-hosted PBX**: wherever your PBX puts recordings. Often a local network share, an object store, or a per-tenant subdomain.

**Playback:** on the call-log list, each row has a play button that opens an inline audio player. The same player appears on the customer's timeline when you expand the call event.

**Compliance:**

* Recording typically requires the caller's consent. Set up your greeting or IVR to announce recording, or your jurisdiction's equivalent.
* A user with view-only access can listen to recordings but not download them. A user with full access can download (the link to the audio file is exposed).

## On the customer's timeline

Every call that's linked to a record shows up on that record's timeline, interleaved with the other channels:

Each call event expands to show: direction and duration, the other party's number, the agent who handled it, the outcome, the recording (if any), and any notes added via the post-call modal.

The same timeline view interleaves email, SMS, WhatsApp, tasks, cases, and field changes, so the call sits in the right _moment of context_.

## Filtering and search in the call-log list

The call-log list supports the usual controls:

* **Search** by number, agent, or matched customer.
* **Filter** by direction (incoming or outgoing), date range, outcome, recorded vs. not recorded, has-note vs. no-note.
* **Sort** by date (default desc), duration, direction, or agent.
* **Export to CSV** uses the same export pipeline as everywhere else in Flexie (filtered and sorted view exported).

A user's access role determines what's visible. See-own vs. see-everyone is the typical split, configured under the standard **Roles** model.

## Manually mapping a past call to a customer

If you spot a call in the log that didn't auto-link to anyone (e.g. because the number wasn't on file at the time), open the call, click **Link to record**, search for the customer, save. The link appears on the customer's timeline retroactively.

A bulk version of this for backfilling history is the **Match past calls to this record** action, see [Workflows](https://flexie.io/resources/phone/workflows-and-automation#match-past-calls-to-this-record).

## Gotchas

* **Incoming and no-answer.** A ringing-but-unanswered call still creates a call record, with the outcome set accordingly. Use this for "called but didn't reach them" workflows.
* **Outgoing and no-answer.** Same, a row is written. The duration reflects what actually happened (zero, in this case).
* **Recording stops at hangup.** Whichever side hangs up first ends the recording, including if the customer hangs up after you've already said "this call is being recorded".
* **Linked-record performance.** A call against a phone that appears on many records (e.g. an account whose main number is also 200 contacts' work number) writes a lot of links. It works, but the timeline rendering is per-record, so each contact sees just the one event.

## Next

* [Live monitor](https://flexie.io/resources/phone/live-monitor): supervising the calls that are happening _right now_.
* [Workflows](https://flexie.io/resources/phone/workflows-and-automation): using a completed call as a workflow trigger.

---

## Channels

Source: https://flexie.io/resources/phone/channels

# Channels

Last updated 26 May 2026

![Two phone-channel options side by side, Twilio cloud telephony on the left and a self-hosted PBX on the right, both feeding the same Flexie softphone](https://flexie.io/image/resources/phone-channels.png)

The two channels Flexie's built-in phone can run on. Pick the one that fits, configure it, give your team access, and the softphone starts working everywhere.

## Picking a channel

A quick decision matrix:

| If you…                                                                                                | Pick                |
| ------------------------------------------------------------------------------------------------------ | ------------------- |
| Have no existing phone system, want to launch in a day, are happy with a third party hosting the calls | **Twilio**          |
| Already run an in-house phone system (or are required to), need recordings to stay on your premises    | **Self-hosted PBX** |

## Channel A: Twilio

### 1\. Connect a Twilio account

In **Twilio Accounts**, click **New**.

| Field                         | Description                                                                                                                                  |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**                      | Friendly label (shown in the account picker, e.g. "Sales account").                                                                          |
| **Account SID**               | Your Twilio Account SID (starts with AC...).                                                                                                 |
| **Auth Token**                | The matching auth token.                                                                                                                     |
| **API Key SID**               | A Twilio **API Key** (starts with SK...). Used by Flexie to sign per-user calls.                                                             |
| **API Secret**                | The matching API secret.                                                                                                                     |
| **Record calls**              | Yes / No. When on, every call placed through this account is recorded. Recordings live on Twilio's servers; Flexie keeps a link to each one. |
| **Incoming call timeout**     | Seconds an incoming call rings before Flexie gives up.                                                                                       |
| **Incoming call failure URL** | A fallback URL Twilio fetches if no Flexie agent picks up before the timeout (e.g. an external voicemail or IVR). Leave blank to hang up.    |

Save. Flexie generates two private webhook URLs for this account that Twilio will use to talk to Flexie. You'll see them on the account's detail page.

### 2\. Add phone numbers

Open **Twilio Numbers** → **New**.

| Field                  | Description                                                                         |
| ---------------------- | ----------------------------------------------------------------------------------- |
| **Phone number**       | Pick a number from the dropdown. Flexie shows the numbers your Twilio account owns. |
| **Friendly name**      | Optional label (e.g. _"Main Sales Line"_).                                          |
| **Users who can call** | The Flexie users authorised to **make voice calls** from this number.               |
| **Users who can SMS**  | The Flexie users authorised to **send SMS** from this number.                       |

Each Twilio number can be assigned to many users; each user can have access to many numbers. When a user makes a call, the dialer offers them the numbers they're allowed to use as the _From_ number.

### 3\. Connect Twilio to Flexie

For Twilio to know how Flexie wants calls handled, paste the two URLs shown on the Twilio account's detail page in Flexie into the matching **Voice URL** and **Status Callback URL** fields on the Twilio side. Twilio's console will guide you to the right place to paste each one.

> Treat those URLs as secrets. If you suspect one has leaked, delete the account in Flexie and re-create it. The new account gets fresh URLs and the old ones stop working immediately.

### 4\. Access control

Anyone you've added to the **Users who can call** list on a Twilio number can use that number to make and receive calls. The Twilio configuration and stats screens have their own access settings, manage them through the standard **Roles** model.

## Channel B: Self-hosted PBX

This channel is for phone systems you operate yourself. Unlike Twilio (where one account holds many numbers), the self-hosted PBX channel uses a **per-user extension**, one extension per Flexie user.

### 1\. Per-user extension

In **VoIP Accounts**, click **New**.

| Field              | Description                                                                                                  |
| ------------------ | ------------------------------------------------------------------------------------------------------------ |
| **Owner**          | Which Flexie user this extension belongs to. A user can only have one.                                       |
| **PBX bridging**   | Yes / No, whether bridging behaviour is on for this account. Leave at your PBX's recommended default.        |
| **Used by all**    | Yes / No. When on, the extension is also usable by every other user. Typically off; useful for shared lines. |
| **Username**       | The username your PBX uses to identify this extension.                                                       |
| **Identity**       | The address presented to the PBX (e.g. 1001@pbx.example.com).                                                |
| **Password**       | The password for this extension.                                                                             |
| **Server**         | Your PBX's hostname.                                                                                         |
| **Global prefix**  | Digits to prepend to _every_ outbound number (e.g. 9 if your PBX needs a 9 for outside calls).               |
| **Global postfix** | Digits to append (rarely needed).                                                                            |

Save. The user's softphone registers to the PBX as soon as they next load a Flexie page.

### 2\. Connect the PBX to Flexie

When the PBX answers or completes a call, it should notify Flexie so the call appears on the customer's timeline. Your PBX integrator wires this up. They'll need three URLs from your Flexie admin (one for inbound notifications, one for outbound notifications, and one for the final call log). Ask Flexie support if you'd like a hand.

### 3\. Access control

By default a user with their own extension can make and receive calls. The call-logs and channel-configuration screens have their own access settings, manage them through the standard **Roles** model.

## Gotchas

* **One Twilio account, many numbers vs. one extension per user.** The two channels model the world differently. Don't try to fight it. If you outgrow per-user PBX extensions, switch channels.
* **The softphone needs a secure (HTTPS) Flexie tenant.** Browsers refuse microphone access from non-secure pages, and without microphone access the softphone can't ring or talk. Make sure your tenant is on an `https://` URL.
* **Browser permission prompts.** The first time a user opens Flexie after the softphone is enabled, the browser asks for **microphone access**. Users who block it can't make or receive calls. There's a prominent in-page warning explaining how to unblock.
* **Outbound caller ID for Twilio** must be a number you own _or_ a verified caller ID. Twilio rejects calls from unowned numbers; the agent gets an error toast.
* **PBX connectivity.** If users sit behind strict firewalls, your PBX team may need to open up specific traffic so the browser can reach the PBX. They'll know what's needed.
* **Recordings.** On Twilio they live on Twilio's servers (Flexie keeps a link, plays them back on demand). On the self-hosted PBX, they live on _your_ infrastructure (Flexie stores whatever link the PBX hands it). Replace the wrong link and the playback button breaks silently. It's a URL, not a guarantee.

## Next

* [The softphone](https://flexie.io/resources/phone/softphone): what users see and do once a channel is configured.
* [Call logs & timeline](https://flexie.io/resources/phone/call-logs-and-timeline): what each call leaves behind.

---

## Live Monitor

Source: https://flexie.io/resources/phone/live-monitor

# Live Monitor

Last updated 26 May 2026

![A live monitor page listing agents and their current call state, with listen, whisper, and barge buttons next to each active call](https://flexie.io/image/resources/phone-live-monitor.png)

A supervisor-only screen that shows every call happening right now, who's on it, and lets you **listen in**, **whisper** to your agent (only they hear you), or **barge in** (everyone hears you). The classic call-centre supervision triad.

> Live monitor is part of the self-hosted PBX channel. It relies on your PBX's listen / whisper / barge primitives. The Twilio equivalent (real-time event stream, call-recording playback) is handled inside Twilio's own console.

## What the page shows

The list updates in real time. New calls appear immediately, completed calls drop off, ringing-to-talking states change without a refresh.

Per agent you see:

| Column        | Meaning                                                                                      |
| ------------- | -------------------------------------------------------------------------------------------- |
| **Agent**     | The user's name and extension.                                                               |
| **Status**    | _Idle_ (logged in, no call), _Ringing_, _Talking_, or _Paused_ (manually away).              |
| **Customer**  | The matched record, or just the number if no match. Clicks through to the customer's record. |
| **Direction** | Incoming or outgoing.                                                                        |
| **Time**      | Elapsed talk time on the current call.                                                       |
| **Controls**  | The three supervision actions (only on active calls).                                        |

## The three supervision actions

### Listen (silent monitor)

You join the call as a silent observer. **Neither the customer nor the agent hears you.** They keep talking; you hear both sides.

Use this for quality assurance, agent training reviews, or "what's happening on the floor right now" awareness.

### Whisper (coach mode)

**The agent hears you**, the customer doesn't. The agent can respond verbally in a way that sounds natural to the customer.

Use this for coaching during a call ("ask them about the renewal date", "I'll take this one in a minute") without breaking the customer experience.

### Barge (full join)

You join the call **fully**: both the customer and the agent hear you and you can talk to both. The call becomes a three-way.

Use this when you need to take over directly: escalation, the agent needs help they can't be coached through, or you need to apologise to a customer in person.

> All three modes are toggled by leaving the supervised call (clicking the End button on your own softphone disconnects you without affecting the agent or customer).

## Setting up live monitor

Admin-only. The page asks for the credentials your PBX uses to expose its management interface to Flexie, plus the three feature codes that drive listen, whisper, and barge.

| Field                       | What it is                                                                                                         |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| **PBX management URL**      | The address Flexie uses to talk to your PBX's management interface (your PBX integrator will have given you this). |
| **PBX management user**     | The username for that interface.                                                                                   |
| **PBX management password** | The matching password.                                                                                             |
| **Listen code**             | The feature code in your PBX's dial plan for **listen-only** mode.                                                 |
| **Whisper code**            | The feature code for **whisper** mode.                                                                             |
| **Barge code**              | The feature code for **barge** mode.                                                                               |

The three codes come from your PBX team. They're the dial-plan shortcuts that one extension uses to spy on another. If they set this up for you, they'll have the three values; paste them in.

Save and the supervision buttons activate on every live call.

> If only the management URL, user, and password are configured but the feature codes aren't, the page still shows live call state (you can see who's talking) but the listen / whisper / barge buttons are hidden.

## Permissions

Live monitor is **supervisor-only**. Granting the see-everyone scope on call logs to a role also gives that role access to the live monitor; the configure-everything scope adds the right to manage the settings page and use the supervision buttons.

A user without the see-everyone scope only sees their own calls, meaningless on a supervision page, so the menu item is hidden.

## What it doesn't do

* **No extra recording on the supervisor side.** Listening, whispering, or barging doesn't add a separate recording. The same call-level recording setting applies (the supervisor's audio is mixed in for barge, just like any other party).
* **No call queueing or routing.** Live monitor is a _view-and-act_ page; it doesn't decide where calls go. That's still the PBX's job.
* **No agent-side controls beyond supervision.** You can't force-mute an agent's mic, force-hold a call, or transfer it from this screen. Agents handle their own calls.

## Gotchas

* **PBX management interface must be reachable.** From Flexie's server, you must be able to reach your PBX's management URL. If they're on different networks, open the route.
* **The supervisor's softphone gets a real call.** The supervision is delivered as a call to the supervisor's own extension, so the supervisor needs an extension too (see [Channels](https://flexie.io/resources/phone/channels)).
* **Encryption.** If Flexie is on a secure (HTTPS) URL but the PBX management URL is plain, browsers and the integration may refuse the connection. Run the PBX management over a secure URL too.
* **Feature codes vary by PBX build.** Different PBXes use different feature-code conventions. Test all three modes on your own extensions before relying on them in production.

## Next

* [Workflows](https://flexie.io/resources/phone/workflows-and-automation): the completed-call trigger picks up monitored calls too.
* [Call logs & timeline](https://flexie.io/resources/phone/call-logs-and-timeline): where the completed calls land.

---

## Overview

Source: https://flexie.io/resources/phone/overview

# Overview

Last updated 26 May 2026

![A Flexie softphone panel docked at the bottom-right of the page, a customer record open above it, and a completed call on the timeline](https://flexie.io/image/resources/phone-overview.png)

Flexie has a phone built into the platform. You click a customer's number, your browser rings, you talk, no separate desk phone, no separate softphone app. The phone runs on one of two channels you bring yourself: **Twilio** (a cloud telephony account) or your own **self-hosted PBX**. Either way, what the user sees is the same.

The **softphone panel** sits docked at the bottom-right of every page, where calls ring and where you dial out from.

## What "the built-in phone" is

Three things rolled into one:

1. **A softphone in your browser.** A small fixed panel at the bottom of the screen. Incoming calls ring there; outbound calls dial from there.
2. **Click-to-call from anywhere.** Every phone number on every record (contacts, leads, accounts, deals, cases) is a button that calls the number through your softphone.
3. **Calls that become records.** Every connected call is logged, linked to the right customer, and (where enabled) recorded, appearing on that customer's timeline alongside email, SMS, WhatsApp, and notes.

The phone shares the same conventions as the rest of Flexie's communication: a record gets every channel's history in one place, workflows can react to call events, and a call can lead into an action (create a task, send a follow-up email, change a stage).

## The two channels

You pick one of two channels for your account. Both deliver the same in-browser experience, and both follow Flexie's customer-owned-channels rule, the cloud or the box belongs to you, Flexie integrates with it.

Twilio

A cloud telephony provider. You sign up for a Twilio account, buy phone numbers, plug the credentials into Flexie. Calls go through Twilio's network; recordings live on Twilio's servers. Fast to set up, no infrastructure to manage, global numbers, predictable per-minute pricing.

Self-hosted PBX

Your own phone system that you operate (on-prem or in a data centre). Flexie's softphone talks to it directly from the browser. Right when you already operate a PBX, you have local-loop interconnect, or your regulator requires on-prem recording.

> An account uses one of the two channels, you don't run both together. Pick the one that fits your operation.

## What's in this section

1. [Channels](https://flexie.io/resources/phone/channels): picking a channel, the configuration screens, how phone numbers and user extensions are wired up.
2. [The softphone](https://flexie.io/resources/phone/softphone): the in-browser dialer, answering calls, click-to-call, manual dial, keypad tones, mute, transfer, the after-call note modal.
3. [Call logs & the customer timeline](https://flexie.io/resources/phone/call-logs-and-timeline): how calls are saved against records, what each call record holds, recordings, and where to find them.
4. [Live monitor](https://flexie.io/resources/phone/live-monitor): supervisor view of in-progress calls, with listen / whisper / barge controls.
5. [Workflows](https://flexie.io/resources/phone/workflows-and-automation): the **Completed call** trigger and the **Match past calls to this record** action.

## Where the phone fits in the bigger picture

| What you want                     | Where to go                                                                      |
| --------------------------------- | -------------------------------------------------------------------------------- |
| Set up a phone for the first time | [Channels](https://flexie.io/resources/phone/channels)                                            |
| Make / answer a call              | [The softphone](https://flexie.io/resources/phone/softphone)                                      |
| See a customer's call history     | The customer's timeline, or [Call logs](https://flexie.io/resources/phone/call-logs-and-timeline) |
| Watch / listen to live calls      | [Live monitor](https://flexie.io/resources/phone/live-monitor)                                    |
| Run a workflow after a call       | [Workflows](https://flexie.io/resources/phone/workflows-and-automation)                           |

## Closely related

* [Inbox](https://flexie.io/resources/inbox/overview): the same record hosts the customer's emails, SMS, WhatsApp, **and** calls.
* [Workflows](https://flexie.io/resources/workflows/overview): the **Completed call** trigger is one of many triggers.
* [Custom records & fields](https://flexie.io/resources/customization/custom-records-and-fields): phone fields on a record (Phone / Mobile types) are what click-to-call hooks into.

---

## The Softphone

Source: https://flexie.io/resources/phone/softphone

# The Softphone

Last updated 26 May 2026

![The Flexie softphone panel docked at the bottom-right, showing a connected status dot, a keypad, and an in-call view with quick actions for the matched customer](https://flexie.io/image/resources/phone-softphone.png)

The softphone is the in-browser dialer, a small panel docked at the bottom of every Flexie page. The softphone is visible to any user whose account has a phone channel configured (a Twilio number assigned, or a PBX extension set up, see [Channels](https://flexie.io/resources/phone/channels)). Users with neither don't see it.

## What the panel looks like

The panel is **always docked**. You can collapse it to a small bubble when not in use, but it never closes. The ringer, the keypad tones, and the call audio are all wired into this panel.

### The status dot

The coloured dot in the header shows the connection state:

| Colour | Means                                                              |
| ------ | ------------------------------------------------------------------ |
| Green  | Connected and ready. You can call and receive.                     |
| Yellow | Connecting. Wait.                                                  |
| Red    | Disconnected. Something's wrong, check the in-page warnings below. |

Hover for the last status message.

### The microphone prompt

The first time a user loads Flexie after the softphone is enabled, the browser asks permission to use the microphone. Granting it is mandatory, without it, calls can't carry audio.

If the user blocks the prompt:

> **No microphone access.** Click the camera icon in your browser's address bar to allow microphone, then refresh the page.

The dialer shows this banner until the permission is granted.

## Making a call

There are three ways to start an outbound call.

### 1\. Click-to-call from a record

Open any contact, lead, account, deal, or case. Every **phone field** (Phone, Mobile, Fax, WhatsApp, the field types listed in [Custom records & fields](https://flexie.io/resources/customization/custom-records-and-fields)) shows a phone icon next to it. Click it and the softphone dials.

The dialer panel automatically picks up the record's context (caller name, primary identity, quick links to the customer's open tasks, cases, deals, and notes) and shows them inside the in-call panel.

### 2\. Manual dial

Click the **keypad** button in the softphone header. Type the number (numpad keys also work). When you've entered it, press **Enter** or click **Call**.

Manual dial is gated by a permission: users without it see no keypad button and can only click-to-call from records. Manage it through the standard **Roles** model.

### 3\. From a workflow

**Workflows cannot place a call to a customer on their own.** Phone is not a marketing or broadcast channel, an agent has to be on the line. Workflows can record a "please call back" intent on the customer's record, but the dialling stays in human hands.

## In-call panel

When a call is active, the dialer panel switches to its **in-call** view. It shows:

* **Who you're calling** at the top: matched customer name, the number, and a live timer.
* **Quick actions** for that customer: Open contact, Add task, Add note, Create case, Add deal.
* **Call controls** at the bottom: Mute, Transfer, Keypad, End.

### Controls (every channel)

* **Mute**: toggle your microphone (the other side stops hearing you).
* **Keypad**: sends tones during the call (useful for IVRs that ask you to press a key).
* **End**: hangs up.

### Transfer

The **Transfer** button opens a small popover listing **available agents** (the Flexie users who are right now logged in and idle). Click one and the call is transferred to them; you drop out.

Available on Twilio out of the box. On a self-hosted PBX, transfer depends on what your PBX supports; usually it just works.

### Quick actions during a call

Below the in-call header you'll see contextual buttons for the matched customer:

* **Open contact**: switches the main page to the customer.
* **Add task**: opens the task modal pre-filled with the customer.
* **Add note**: drops a note onto the customer's timeline.
* **Create case**: escalates to a support case.
* **Add deal**: starts a new deal off the call.

If no customer matched the number, you get:

* **Create lead** / **Create contact**: captures the number into a new record on the fly. The call's already in progress; this just gives the call somewhere to land on a timeline once it ends.

## Incoming calls

When a call rings your extension, the dialer panel jumps to the **incoming** view. It shows the matched customer (if any), the caller's number, and a list of related records (open deals, cases, tasks) so you know who's calling **before you pick up**.

Click **Answer** to take the call; **Decline** to send it to voicemail (Twilio) or to free up the line (PBX).

### How the customer is matched

Flexie searches every phone field across leads, contacts, accounts, deals, cases, and users for the incoming number, first making sure it's in international format. Anything that matches is offered as a quick link.

If nothing matches, the incoming view shows just the caller's number and the _Create lead_ / _Create contact_ buttons.

## After the call: the note modal

When you hang up, a small modal opens with two things:

| Field      | What it does                                                                                                                                                                          |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Notes**  | Free text, the body of the note added to the customer's timeline.                                                                                                                     |
| **Status** | If the customer's record type has a configured _status field_ (e.g. lead status, deal status, case status), you can update it right here. The choices come from that field's options. |

Saving creates a note linked to the call's customer and the call record. The note becomes a row on the customer's timeline alongside the call, so when you come back tomorrow, both are visible together.

If you click **Skip**, the call is still logged; you just don't add a note.

> The post-call modal opens by default. It's how teams turn calls into CRM updates rather than letting calls evaporate. If a user really doesn't want it, there's an account-level switch in their preferences.

## Keypad tones during the call

The keypad button in the in-call panel sends tones, necessary for the _"Press 1 for sales, 2 for support"_ moment. The panel plays the local tone (so you hear what you pressed) and signals the remote side.

Keyboard shortcuts work too:

* `0` to `9` for digits
* `*` for asterisk
* `#` for pound
* Numpad keys (`0` to `9`) for the same

## Limits and gotchas

* **One call at a time per user.** A second incoming call rings the caller back as busy (the line is occupied). For more concurrency, use call queues / IVR routing on the PBX or Twilio side, not Flexie.
* **The panel doesn't survive a hard refresh during a call.** If you reload the page mid-call, the call drops. Soft-navigation (clicking a Flexie link) doesn't drop it, the panel is shared across pages.
* **Transfer is best-effort.** "Available agents" lists users currently in Flexie with no active call. If they decline or don't answer, the call goes back to the queue.
* **Recording starts when the call answers**, not when it begins ringing. Voicemails and pre-answer audio aren't captured.
* **The customer-match step needs numbers in a consistent format.** See [Handling messy phone data](https://flexie.io/resources/inbox/sms#handling-messy-phone-data-append-country-prefix) for the same trick on the phone side: configure a default country prefix and your messy phone data still matches.

## Next

* [Call logs & timeline](https://flexie.io/resources/phone/call-logs-and-timeline): what happens to the record of the call after it ends.
* [Workflows](https://flexie.io/resources/phone/workflows-and-automation): trigger a workflow after a call ends.

---

## Workflows

Source: https://flexie.io/resources/phone/workflows-and-automation

# Workflows

Last updated 26 May 2026

![A completed call on the left, a workflow trigger firing in the middle, and a follow-up action (Add task, Send email, Update field) running on the right](https://flexie.io/image/resources/phone-workflows-and-automation.png)

When a call ends, an automation can pick up. Log a follow-up task, send a thank-you SMS, change a deal stage, fire any other workflow action. This page is the consolidated guide to the **Completed call** trigger and the **Match past calls to this record** action.

For workflow fundamentals (building, runtime, parallel branches, passing data) see [Workflows](https://flexie.io/resources/workflows/overview).

## At a glance

## Trigger: Completed call

Use this when you want a workflow to react **after a call wraps up**: log a follow-up, send a thank-you, escalate to a case, change a deal stage.

The trigger exists on both channels (Twilio and the self-hosted PBX). The form is the same on both; you just pick whichever your account uses.

### Form fields

| Field               | What it does                                                                                                                   |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| **Call direction**  | _Any_, _Incoming_, or _Outgoing_. Restrict to calls in this direction.                                                         |
| **First call only** | Yes / No. When **Yes**, the workflow only runs on the customer's **very first** completed call. Subsequent calls don't run it. |

### When the trigger runs

The trigger runs after a call ends, **but only if all three of these are true**:

1. The call was **answered** (someone picked up).
2. The call had **measurable talk time** (it wasn't just a momentary pickup-and-drop).
3. The call was **recorded**, on channels where recording is on.

So:

* A **missed** call doesn't run it.
* A **busy** or **declined** call doesn't run it.
* A call where **recording is off** doesn't run it, even if it was a great conversation.

> If you need to react to missed calls or to calls without a recording, take a different route. For example, a periodic workflow that checks the call-logs list, or a workflow off the customer record's field changes when an agent updates a status in the post-call modal.

## Important: what the trigger gives you

The trigger tells the workflow _that a call happened_, but it **doesn't** drop a bag of call details into your workflow.

In other words: when your workflow's next step runs, it knows _which customer_ the call was about (the record the workflow is running on), but it doesn't automatically know that specific call's duration, recording link, agent, or direction.

That's an intentional design point. Most automations just need to know "a call happened, do X next". For workflows that need the specific call details, two patterns:

### Pattern 1: use the customer's own fields

The post-call note modal updates the record's _status_ field (lead status, deal status, case status, whichever's configured). A workflow can read that field like any other:

```
Decision    Status = "Qualified"?
   ├─ Yes ─► Action  Send email           template: "Welcome to onboarding"
   │
   └─ No  ─► Action  Add task             "Follow up, qualify lead"

```

### Pattern 2: use the customer's call history

If you really need the call's duration, recording link, or other specifics, the most recent call against the customer is queryable through Flexie Scripting. Your platform admin will give you the exact snippet for your account. The example below is illustrative:

```twig
{# Pull the customer's most-recent call, your admin will give you
   the exact field names for your account. #}
{% set last_call = ... %}

Last call was {{ last_call.duration }} seconds.
Recording: {{ last_call.recording_url }}

```

For most teams this is overkill. The post-call note modal plus customer-record fields are usually enough.

## Action: Match past calls to this record

A **bulk backfill** action. Scans the call history and attaches past calls to the workflow's customer record whenever the call's caller or callee number matches one of the record's phone fields.

### When to use it

After importing customer records that already have phone numbers, run this action on every newly imported lead or contact to attach **historical calls** that happened before the record existed.

Typical workflow:

```
Trigger    Record created                   (any new contact / lead)
   │
   ▼
Action     Match past calls to this record  phone fields: Mobile, Phone

```

When the action runs, it looks at every value in the selected fields and attaches every past call whose number matches.

### Form fields

| Field            | What it does                                                                                                                      |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **Phone fields** | Pick the fields on the record whose values should be tried as match keys. Choices come from the record's Phone and Mobile fields. |

> The action lives on the self-hosted PBX channel. On Twilio, historical calls are linked the moment they come in (the auto-link step runs as part of the call's lifecycle), so there's no separate backfill needed.

## Common recipes

### 1\. After every answered call → create a follow-up task

The task is created against the same customer the call was linked to.

### 2\. First-ever incoming call → trigger onboarding sequence

### 3\. Backfill historical calls when a record is imported

Every past call to or from the new record's phone number is linked retroactively, and the call events show up on the customer's timeline.

### 4\. Use the post-call status field to branch a workflow

## Gotchas

* **Gating-only trigger, no extra data.** This bears repeating because every team learning this trips on it once. The trigger tells the workflow a call happened; it doesn't make the call's duration, recording, or agent automatically available.
* **Recording required.** If your channel doesn't record (compliance, cost), the trigger doesn't run. Build the automation off a different signal, e.g. a status change in the post-call modal.
* **First-call detection is per customer.** _"First call"_ means "first call linked to this specific customer record". A call from the same number that linked to a different record (e.g. a lead vs a contact) counts as "first" on each: fire-once-per-customer, not fire-once-per-number.
* **Same-call-many-customers.** A call that links to multiple records (e.g. an account _and_ a contact) runs the workflow once per record. If you want only one to run, restrict the workflow's record type accordingly.

## Next

* [Live monitor](https://flexie.io/resources/phone/live-monitor): for _real-time_ call supervision, alongside the post-call workflow trigger covered here.
* [Workflows](https://flexie.io/resources/workflows/overview): the engine these triggers and actions plug into.
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): the language used in message bodies and decision expressions.

---

## Data Grid Reports

Source: https://flexie.io/resources/reports/data-grid-reports

# Data Grid Reports

Last updated 25 May 2026

![A Flexie data grid report showing a query, user filters, and the resulting sortable paginated table](https://flexie.io/image/resources/reports-data-grid-reports.png)

You write a `SELECT` query. Flexie runs it, applies any user-supplied filters and sorting on top, and shows the result as a paginated table with column headers you can click to sort. The user can change filters, change the sort, adjust the page size, and **export the full result to CSV**.

This is the right choice for any report whose output is rows-and-columns: a list of overdue invoices, top customers by lifetime value, agent activity, and so on. Start at **Reports** (`/reports`), click **New**, set output format to **Data Grid**.

## The shape of a data grid report

## The report settings

| Setting                         | Purpose                                                                                                                                                                                   |
| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**                        | Required. Shown in the reports list, the report's view page, and any dashboard widget that uses it.                                                                                       |
| **Description**                 | Optional notes shown on the view page.                                                                                                                                                    |
| **Category**                    | Optional folder for grouping reports.                                                                                                                                                     |
| **Output format**               | **Data Grid** (the topic of this page).                                                                                                                                                   |
| **Query**                       | The SELECT statement. Required. The largest field on the form.                                                                                                                            |
| **Filters (JSON)**              | Optional user-input filters shown above the report (see below).                                                                                                                           |
| **Default order column**        | Which column the result is sorted by when first opened.                                                                                                                                   |
| **Default order direction**     | Ascending or Descending.                                                                                                                                                                  |
| **Who can access this report?** | Who can open this report. Combinations of All Users, specific roles, user groups, or individual users. See [Access control](https://flexie.io/resources/reports/viewing-exporting-sharing#access-control). |

## Writing the query

The body of a data grid report is a single `SELECT` statement.

### Simple example

```sql
SELECT id, name, owner_id, amount, stage_id, date_added
FROM deals
WHERE is_won = 1
ORDER BY amount DESC

```

That is a complete, working report. Save it and open the view page.

### Joins and aggregations

`JOIN`s, `GROUP BY`, aggregation functions, anything `SELECT` supports, are allowed:

```sql
SELECT u.full_name, COUNT(d.id) AS deal_count, SUM(d.amount) AS total
FROM deals d
JOIN users u ON u.id = d.owner_id
WHERE d.is_won = 1
GROUP BY u.id
ORDER BY total DESC

```

### Common Table Expressions (`WITH ...`)

You can prepare data in a `WITH` clause before your main `SELECT`. This is the "query data before creating your own query" pattern, useful when the result depends on an intermediate calculation:

```sql
WITH won_deals AS (
  SELECT owner_id, amount FROM deals WHERE is_won = 1
)
SELECT owner_id, SUM(amount) AS total
FROM won_deals
GROUP BY owner_id
ORDER BY total DESC

```

The same restrictions (read-only, no `SELECT *`, no restricted tables, see below) apply to both the CTE sub-query and the main statement.

## What the query can do, and what it can't

To keep reports fast and safe, Flexie enforces these rules at run-time.

### Read-only

Only `SELECT` and `WITH` are accepted. Anything that would change or delete data is **rejected at save time**: `INSERT`, `UPDATE`, `DELETE`, `DROP`, `TRUNCATE`, `CREATE`. You can't even save such a report.

### `SELECT *` is forbidden

You must list the columns you want. The query is rejected if it uses `SELECT *` or `SELECT <table>.*`. Reasons: speed, and to keep the column list predictable for filters and sorting.

### Hard row cap of 1,000

Every report is capped at **1,000 rows**. If your query would naturally return more, only the first 1,000 are kept. If you specify a `LIMIT` higher than 1,000, Flexie quietly caps it. If you need a wider total, **aggregate inside the query** (`SUM`, `COUNT`, `GROUP BY`) rather than summing in the template.

### Some tables are off-limits

A short list of sensitive tables can't be queried: settings, attachments metadata, lead point-change logs, IP cross-references, mailbox or SMTP credentials, addon integration settings. You'll get an error at save time if you reference them.

## Placeholder variables Flexie injects for you

Five tokens are automatically replaced **before the query runs**, so you can write user-aware reports without hard-coding ids:

| Placeholder | Replaced with                                                                                                                                |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| {user\_id}  | The signed-in user's id                                                                                                                      |
| {group\_id} | The signed-in user's group id (\-1 if they are not in one)                                                                                   |
| {role\_id}  | The signed-in user's role id (\-1 if they don't have one)                                                                                    |
| {timezone}  | The signed-in user's timezone (or the system default if not set)                                                                             |
| {filters}   | The SQL WHERE fragment generated from the user-input filters (see below). Typically you place this where you want filter conditions to land. |

`{{user_id}}` (double-braced) is also accepted as a synonym.

### Examples

```sql
-- Only deals the signed-in user owns
SELECT id, name, amount, stage_id
FROM deals
WHERE owner_id = {user_id}
ORDER BY date_added DESC

```

```sql
-- What this user's group is currently working on
SELECT id, name, owner_id, stage_id
FROM deals
WHERE owner_id IN (SELECT id FROM users WHERE group_id = {group_id})
ORDER BY date_modified DESC

```

```sql
-- Apply user-supplied filters where they belong in your query
SELECT id, name, amount, stage_id, date_added
FROM deals
WHERE is_published = 1
  {filters}
ORDER BY amount DESC

```

If the user picks "Status = Won" in the report's filters, `{filters}` is replaced with `AND stage_id IN (...)` or whatever the chosen filter resolves to.

## User-input filters

A report can offer filters at view time: drop-downs, date pickers, text boxes above the grid that the viewer can fill in to narrow the result. You configure them in the **Filters** JSON setting on the report (the filter editor at `/reports/filters/{id}`).

A quick taste:

```json
[
  {
    "alias": "date_added",
    "label": "Date Added",
    "type": "datetime"
  },
  {
    "alias": "is_won",
    "label": "Outcome",
    "type": "select",
    "properties": {
      "options": {
        "1": "Won",
        "0": "Lost or open"
      }
    }
  }
]

```

That is two filters: a date range and a yes/no drop-down. The options of a `select` are a **key → label map**: the key is what flows into the query, the label is what the viewer sees.

The six filter types are `text`, `select`, `number`, `date`, `datetime`, and `time`. The viewer gets an operator drop-down for text, number, and select; date types use From/To range pickers.

### Where filter values land in your query

If your query contains `{filters}`, that token expands to the user's selected conditions as an SQL fragment (or `1=1` if no filters are active):

```sql
SELECT id, name, amount, stage_id, date_added
FROM deals
WHERE is_published = 1
  AND {filters}
ORDER BY date_added DESC

```

If your query does not contain `{filters}`, the values are still applied. Flexie wraps your query and pushes them into the outer `WHERE` for you. The trade-off: you don't control _where_ they land. Use `{filters}` when placement matters.

### Filters can be driven by Flexie Scripting themselves

The Filters JSON is rendered through [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) before being parsed. A `select`'s options can come from a live query (build the option list with a `{% for %}` loop over `query("SELECT ...")`), labels can be date-aware, and filters can be conditionally shown.

> Filters are deep enough to deserve their own page. See **[Report filters (in depth)](https://flexie.io/resources/reports/filters)** for the full treatment: every type and its operators, the three substitution modes (`{filters}` placeholder, automatic, and `manual`), the `__sql_filters` variable, and using Flexie Scripting inside the filter JSON to build dynamic option lists.

## Column behaviour at view time

The user can interact with the grid:

* **Click any column header** to sort by that column. Click again to reverse.
* **Change the page size** (number of rows per page).
* **Apply or clear filters** above the grid.

These choices are remembered **per user, per report**. When they come back, their last filter set, sort, and page size are still there. This is why two people can open the same report and see slightly different things; they are not seeing different data, they are seeing the same data with their own preferences.

The default sort comes from the report's **Default order column** and **Default order direction** settings.

## Validation and errors

* **At save time**, Flexie checks your query is read-only, doesn't use `SELECT *`, and doesn't reference forbidden tables. If it fails, the report won't save and you'll see the reason.
* **At view time**, if the query has a syntax error, you'll see the database error on the view page (and only people who can view the report see it). Fix the query and save.

## Performance tips

* **Aggregate in the query.** Don't pull 10,000 rows to sum in the template; use `SUM`, `COUNT`, `GROUP BY` in the `SELECT`.
* **Filter early.** Push narrowing `WHERE` clauses on the largest tables first.
* **Index-friendly columns in `WHERE`.** Equality on indexed columns (`id`, `owner_id`, `is_won`, `stage_id`) is fast; `LIKE '%…%'` on a free-text column is slow.
* **Avoid wide joins** when a sub-query or CTE would do.
* **The 1,000-row cap is your friend.** A query that _could_ return millions of rows is not suddenly safe with `LIMIT 1000`; the database may still scan everything to find the first 1,000\. Filter, then limit.

## Next steps

* [Report filters (in depth)](https://flexie.io/resources/reports/filters): the dedicated deep guide on the Filters JSON, types, operators, the three substitution modes, the `manual` flag, and using Flexie Scripting to drive filter options.
* [HTML reports](https://flexie.io/resources/reports/html-reports): when the data grid isn't the presentation you want.
* [Viewing, exporting & access](https://flexie.io/resources/reports/viewing-exporting-sharing): what the user sees on the report page, and CSV export.
* [Reports in workflows and dashboards](https://flexie.io/resources/reports/reports-in-workflows-and-widgets): using the saved report from a script or as a widget.

---

## Report Filters (in depth)

Source: https://flexie.io/resources/reports/filters

# Report Filters (in depth)

Last updated 25 May 2026

![A report filter editor on the left, the controls a viewer sees in the middle, and the resulting query with filter values applied on the right](https://flexie.io/image/resources/reports-filters.png)

A report's query is the _shape_ of an answer. Filters are how the person opening the report **tightens that shape at view time**, without editing the query.

A report titled "Won deals by salesperson" with a `Date Added` filter is the same report whether someone wants this week, this quarter, or the last twelve months. They pick the window above the grid; the report runs against that window; the CSV export uses the same window.

A report with no filters is fine. A report with the right filters is **one report instead of twelve**.

A report's filters are edited from the report itself; the filter editor lives at the direct URL `/reports/filters/{id}`.

## How filters move through the system

You write the JSON once; everyone who opens the report sees the controls you defined; their inputs flow into your query.

## The Filters JSON

The **Filters** setting on a report is a single JSON array. Each entry is either:

* an **object** that defines one user-facing filter, or
* the string literal **`"manual"`**, a flag that switches the whole report into [manual mode](#mode-3-manual-mode-filter-values-as-scripting-variables).

The editor is a JSON code editor with syntax highlighting and auto-complete on the well-known keys (`alias`, `label`, `type`, `properties`, `options`, and the type values).

### Filter object shape

```json
{
  "alias": "date_added",
  "label": "Date Added",
  "type": "datetime",
  "properties": {}
}

```

| Field      | Required    | What it means                                                                                                                     |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
| alias      | **yes**     | The column name (or table-qualified t.col) the filter targets in your query. This is what gets compared against the user's value. |
| label      | **yes**     | The visible label shown above the grid. Plain text, anything you like.                                                            |
| type       | **yes**     | The control to render. One of the six [filter types](#the-six-filter-types).                                                      |
| properties | conditional | Type-specific configuration. Required for select (its options map). Ignored for other types.                                      |

### A minimal example

```json
[
  {
    "alias": "date_added",
    "label": "Date Added",
    "type": "datetime"
  },
  {
    "alias": "close_date",
    "label": "Close Date",
    "type": "datetime"
  },
  {
    "alias": "valid_email",
    "label": "Valid Email",
    "type": "select",
    "properties": {
      "options": {
        "1": "Yes",
        "0": "No"
      }
    }
  }
]

```

That's three filters: two date ranges and a yes/no drop-down.

### Validation at save time

When you click **Save** on the filter editor, Flexie:

1. Renders the JSON through the [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) engine first (so any `{{ ... }}` expressions you wrote produce their final values).
2. Parses the result as JSON.
3. Walks the array and rejects anything malformed.

The JSON is rejected if:

* It isn't valid JSON **after** scripting runs.
* A filter entry is missing `alias`, `label`, or `type`.
* The `type` isn't one of `text`, `select`, `datetime`, `date`, `time`, `number`.
* A `select` filter has no `properties.options`.

You'll see the error inline above the editor. The report's existing filter definition stays in place until you save a valid one.

## The six filter types

| type     | Control the viewer sees                                | What it filters against                 |
| -------- | ------------------------------------------------------ | --------------------------------------- |
| text     | A text input + operator drop-down                      | A string column                         |
| number   | A numeric input + operator drop-down                   | A numeric column                        |
| select   | A drop-down populated from your properties.options map | A column whose values appear in the map |
| date     | A date picker (with **From** / **To** for ranges)      | A DATE column                           |
| datetime | A date+time picker (with **From** / **To** for ranges) | A DATETIME column                       |
| time     | A time picker (with **From** / **To** for ranges)      | A TIME column                           |

The **operator drop-down** appears next to text, number, and select inputs. Date, datetime, and time use From/To range fields directly without an explicit operator selector.

### Operators per type

| Type                   | Operators                                                                                    |
| ---------------------- | -------------------------------------------------------------------------------------------- |
| text                   | equals, does not equal, contains, does not contain, starts with, ends with, empty, not empty |
| number                 | equals, does not equal, greater than, less than, greater than or equal, less than or equal   |
| select                 | equals, does not equal, empty, not empty                                                     |
| date / datetime / time | Range only (**From** / **To**), no explicit operator selector                                |

For dates, leaving **From** empty means "no lower bound"; leaving **To** empty means "no upper bound"; filling only one of them is fine and common.

### The `select` `options` map

A `select` filter must specify `properties.options` as an **object** whose **keys are the values stored in the database** and whose **values are the labels shown in the drop-down**:

```json
{
  "alias": "is_won",
  "label": "Outcome",
  "type": "select",
  "properties": {
    "options": {
      "1": "Won",
      "0": "Lost or open"
    }
  }
}

```

When the user picks "Won", the value `"1"` is what flows into the query.

> The labels are not localised by Flexie. What you type is what the user sees. Use the language your team uses.

## How user input reaches your query

Filter values are persisted in the user's **session**, keyed per report (`flexie.report.{id}.filters`). They survive page reloads and pagination for that user, and the **CSV export uses the same filters** as the current view.

Where the values actually get applied depends on **how your query is shaped**. There are three modes, in order of how Flexie decides.

### Mode 1, `{filters}` placeholder in the query

The most common pattern. You put `{filters}` (or `{{filters}}`, the two are synonyms) somewhere in your `WHERE` clause, and Flexie substitutes a ready-built fragment:

```sql
SELECT id, name, amount, stage_id, date_added
FROM   deals
WHERE  is_published = 1
  AND  {filters}
ORDER  BY date_added DESC

```

With the user's input, say _Outcome = Won_ and _Date Added From = 2026-01-01_, the `{filters}` token expands to:

```sql
(`deals`.`is_won` = '1' AND `deals`.`date_added` >= '2026-01-01')

```

When the user hasn't picked any filters, `{filters}` is replaced with **`1=1`**, a no-op so the surrounding `AND` doesn't dangle. You don't need to write conditional SQL.

The fragment is built by Flexie's own query-builder. Values are parameter-safe (it parameterises and then inlines), and column names are back-ticked. Operators chosen by the user are honoured (`contains` becomes `LIKE '%...%'`, `greater than` becomes `>`).

### Mode 2, no placeholder, no `manual` flag

If your query doesn't include `{filters}` _and_ the filter array doesn't include `"manual"`, the filter values are still applied. Flexie passes them behind the scenes to the report's data layer, which wraps your query and adds the same `WHERE` clause around it.

This is convenient: you can add a `Filters` JSON to _any_ report without touching its SQL, and the filters just work.

> The trade-off: you can't choose _where_ the filters land. If your query has a `HAVING` clause, a sub-query, or a `JOIN` where the filter belongs against a joined table, prefer **Mode 1** so you control placement.

### Mode 3, `manual` mode: filter values as scripting variables

If the filter array contains the string `"manual"`:

```json
[
  { "alias": "year", "label": "Year", "type": "number" },
  { "alias": "owner_id", "label": "Owner", "type": "select",
    "properties": { "options": { "12": "John D.", "13": "Jon D." } } },
  "manual"
]

```

Flexie does **not** generate any `WHERE` fragment. Instead, the user's inputs are exposed as Flexie Scripting variables inside the SQL, each keyed by its `alias`, and the auto-generated SQL fragment is also exposed as the variable `__sql_filters`.

You then weave the values into the query yourself:

```sql
SELECT id, name, amount
FROM   deals
WHERE  YEAR(date_added) = {{ year.input | number_format(0, '', '') }}
  AND  owner_id         = {{ owner_id.input }}
{% if amount_min %}
  AND  amount >= {{ amount_min.input }}
{% endif %}
ORDER  BY amount DESC

```

What each variable looks like:

```twig
{{ year       | json_encode | raw }}
{# →  {"operator":"eq","input":"2026"}                          #}

{{ owner_id   | json_encode | raw }}
{# →  {"operator":"eq","input":"12"}                            #}

{{ __sql_filters }}
{# →  (`year` = '2026' AND `owner_id` = '12')                   #}

```

Use `.input` to get the user-typed value. Use the whole object when you also care about the operator the user picked. Use `__sql_filters` when you want the same `WHERE` clause Flexie _would_ have built, handy for "use the auto-built filter as a sub-clause and add my own conditions next to it".

> Manual mode gives you total control but turns the filter into your problem. You decide how each value is used, including handling empty inputs. Wrap each filter use in `{% if ... %}` so empty fields don't break the SQL.

## Driving the filter definition itself with Flexie Scripting

This is the powerful, easy-to-miss part. **The Filters JSON is rendered through [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) before being parsed.** Anywhere inside the JSON you can write `{{ ... }}` expressions, and they will be replaced with their results at the moment the report opens. The combined output then has to be valid JSON for the parser to accept it.

What this unlocks:

* **A drop-down whose options come from a live query.** Pick from your actual users, stages, statuses, products, custom-record types.
* **Filters that include the current user's identity in their labels.**
* **Conditional filters.** Only render certain filters if the viewer has a permission, or only if some data is present.
* **Date defaults that update as time passes.** "From: last 30 days" by default.

### Pattern 1, dynamic `select` options from a query

Build the options map by looping over rows. The output between the braces must be a JSON object after rendering, so emit `"key": "value"` pairs with commas between them:

```json
[
  {
    "alias": "owner_id",
    "label": "Owner",
    "type": "select",
    "properties": {
      "options": {
        {% for u in query("SELECT id, first_name, last_name FROM users WHERE is_published = 1 ORDER BY first_name LIMIT 200") %}
          "{{ u.id }}": "{{ u.first_name }} {{ u.last_name }}"{% if not loop.last %},{% endif %}
        {% endfor %}
      }
    }
  }
]

```

After the script runs, the saved JSON effectively becomes:

```json
[
  {
    "alias": "owner_id",
    "label": "Owner",
    "type": "select",
    "properties": {
      "options": {
        "12": "John Doe",
        "13": "Jon Doe",
        "14": "Jane Doe"
      }
    }
  }
]

```

…which is what the JSON parser accepts. The viewer opens the report and sees a drop-down of real owners, updated every time they open the report.

> Keep the `LIMIT` reasonable. The drop-down is built every open; thousands of options is unhelpful both for performance and for the person scanning the list. Build a `text` filter against an indexed column if your domain is large.

### Pattern 2, status drop-down driven by a small entity lookup

For statuses, pipeline stages, custom-record types, anything you don't hand-curate:

```json
[
  {
    "alias": "stage_id",
    "label": "Pipeline Stage",
    "type": "select",
    "properties": {
      "options": {
        {% for s in query("SELECT id, name FROM stages WHERE is_published = 1 ORDER BY ordering_no") %}
          "{{ s.id }}": "{{ s.name }}"{% if not loop.last %},{% endif %}
        {% endfor %}
      }
    }
  }
]

```

### Pattern 3, default a date filter to "last 30 days"

The Filters JSON only defines the controls; default _values_ aren't part of the schema. But you can put dynamic _labels_ in:

```json
[
  {
    "alias": "date_added",
    "label": "Created (defaults to last 30 days, clear to widen)",
    "type": "datetime"
  }
]

```

Combine with `manual` mode if you want the default to actually apply:

```sql
SELECT id, name, date_added
FROM   leads
WHERE  date_added >= '{% if date_added.from %}{{ date_added.from }}{% else %}{{ dateAdd(now(), -30, "days", "Y-m-d") }}{% endif %}'
  {% if date_added.to %}
    AND date_added <= '{{ date_added.to }}'
  {% endif %}
ORDER BY date_added DESC

```

### Pattern 4, hide a filter unless the viewer has the data

```json
[
  {% set has_quotes = query("SELECT COUNT(*) AS n FROM quotes LIMIT 1")[0].n %}
  {% if has_quotes > 0 %}
  {
    "alias": "quote_status",
    "label": "Quote Status",
    "type": "select",
    "properties": {
      "options": { "draft": "Draft", "sent": "Sent", "accepted": "Accepted" }
    }
  }
  {% endif %}
]

```

> Mind the JSON commas if you're using `{% if %}` between filter objects. Pre-rendering tip: open the edit page, watch the live view, and check the browser's view-source on the filter HTML. What comes through is the JSON _after_ scripting renders.

### What you can call from inside the filter JSON

Everything that's available in [Flexie Scripting](https://flexie.io/resources/flexie-scripting/function-reference), the same sandboxed function set used elsewhere. Most useful here:

* **`query("SELECT ...")`**, for option lists from your own data.
* **`findOne(...)`, `findMany(...)`, `findCount(...)`**, small lookups by field.
* **`now()`, `date(...)`, `dateAdd(...)`**, for date-relative defaults and labels.
* **`getUserById(id)`**, when you know a specific user id and want to look it up.

> The filter JSON is rendered with **no record context**. There is no "current viewer" object, no implicit globals. If you need to scope a _query_ to the current viewer, that's what the `{user_id}` placeholder is for, used in your SQL body, not in the filter JSON.

The same row-cap and read-only restrictions apply as anywhere else. See [Where scripting runs and its limits](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits).

## The placeholder family in queries

`{filters}` isn't the only token you can drop into a query. Five tokens are replaced before the SQL runs (the double-brace forms are synonyms):

| Placeholder                 | Replaced with                                                 |
| --------------------------- | ------------------------------------------------------------- |
| {user\_id} / {{user\_id}}   | The signed-in user's id                                       |
| {group\_id} / {{group\_id}} | Their group id (\-1 if none)                                  |
| {role\_id} / {{role\_id}}   | Their role id (\-1 if none)                                   |
| {timezone} / {{timezone}}   | Their timezone (UTC if not set)                               |
| {filters} / {{filters}}     | The generated WHERE fragment, or 1=1 if no filters are active |

These work in any report, data grid or HTML, and they work in CTEs as well as the main query.

## How users use the filter controls

When someone opens the report:

* A row of **"+ Add filter"** controls appears above the grid, one per filter you defined.
* Picking a filter adds it as a chip with an operator drop-down (for text, number, and select) and the value input(s).
* Clicking **Apply** runs the report with the chosen values.
* Filters are remembered per-user, per-report, across pagination, until cleared.
* Clearing all filters and applying produces the unfiltered result (with `{filters}` resolving to `1=1`).
* **Export to CSV** uses the same active filters as the current view.

When the user reopens the report a day later, same browser, same login, their last filter set is still there.

## Recipes

### Owner drop-down populated from real users

```json
[
  {
    "alias": "owner_id",
    "label": "Owner",
    "type": "select",
    "properties": {
      "options": {
        {% for u in query("SELECT id, first_name, last_name FROM users WHERE is_published = 1 ORDER BY first_name LIMIT 200") %}
          "{{ u.id }}": "{{ u.first_name }} {{ u.last_name }}"{% if not loop.last %},{% endif %}
        {% endfor %}
      }
    }
  }
]

```

> **"Just me" pattern.** A drop-down can't pre-select the current viewer from inside the filter JSON (there is no viewer in scope here). What you _can_ do is build a separate report that hard-scopes to the viewer via the `{user_id}` SQL placeholder, `WHERE owner_id = {user_id}`, and share that as the "My …" version of the report.

### Date-range with sensible default in `manual` mode

```json
[
  { "alias": "date_added", "label": "Date Added", "type": "datetime" },
  "manual"
]

```

```sql
SELECT id, name, amount, date_added
FROM   deals
WHERE  date_added >= '{{ date_added.from ?: dateAdd(now(), -30, "days", "Y-m-d") }}'
  {% if date_added.to %}
    AND date_added <= '{{ date_added.to }}'
  {% endif %}
ORDER BY date_added DESC

```

### Multi-purpose status filter, options from data

```json
[
  {
    "alias": "stage_id",
    "label": "Stage",
    "type": "select",
    "properties": {
      "options": {
        {% for s in query("SELECT id, name FROM stages WHERE is_published = 1 ORDER BY ordering_no") %}
          "{{ s.id }}": "{{ s.name }}"{% if not loop.last %},{% endif %}
        {% endfor %}
      }
    }
  }
]

```

### Text contains, scoped to a column

```json
[
  { "alias": "email", "label": "Email contains", "type": "text" }
]

```

```sql
SELECT id, first_name, last_name, email
FROM   contacts
WHERE  is_published = 1
  AND  {filters}
ORDER  BY date_added DESC

```

The user picks `contains` (default for text), types `acme`, and the `{filters}` token expands to `` (`contacts`.`email` LIKE '%acme%') ``.

## Gotchas

* **A `select` filter without `properties.options` fails to save.** You must supply the map.
* **The values in the `options` map are strings**, even for integer ids in the database. Flexie compares them as strings against the column; comparisons against integer columns work because the database casts.
* **`select` is single-value.** If you need multi-pick, build a `text` filter with the `contains` operator against a CSV column, or model the values as separate boolean flags.
* **`{filters}` resolves to `1=1` when no filter is active.** Design your surrounding `WHERE` to keep working with that. Putting `AND {filters}` at the end is the safest pattern.
* **In `manual` mode, empty inputs are _not_ skipped automatically.** A user who didn't pick a value still gets a (blank) variable injected. Guard every use with `{% if ... %}` or default with `?:`.
* **The filter aliases must match your column names.** A typo here doesn't fail validation, it'll just produce an SQL error at view time.
* **Avoid `LIMIT` on the data-feeding `query(...)` calls inside filter JSON that exceed a few hundred.** Drop-downs are not lists you scroll through, and the query runs on every report open.

## What this connects to

* [Data Grid reports](https://flexie.io/resources/reports/data-grid-reports): where the `{filters}` placeholder is most often used.
* [HTML reports](https://flexie.io/resources/reports/html-reports): filters work for HTML reports too. The difference is that _you_ decide where the values appear (the filter values are available to your template as scripting variables, in manual mode, or pre-baked into the SQL via the same `{filters}` token).
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): the language used both inside the Filters JSON itself and inside a manual-mode SQL body.
* [Reports in workflows and dashboards](https://flexie.io/resources/reports/reports-in-workflows-and-widgets): when a report drives a dashboard widget, the report's filters can be preset for the widget viewer; filter handling and persistence still apply.

## Next steps

* [Viewing, exporting & access](https://flexie.io/resources/reports/viewing-exporting-sharing): how the view page works and how CSV export honours filters.
* [Reports in workflows and dashboards](https://flexie.io/resources/reports/reports-in-workflows-and-widgets): using filtered report data from elsewhere.

---

## HTML Reports

Source: https://flexie.io/resources/reports/html-reports

# HTML Reports

Last updated 25 May 2026

![A Flexie HTML report template rendering as a custom KPI dashboard page with cards and a chart](https://flexie.io/image/resources/reports-html-reports.png)

When you choose **HTML** as the output format, the report's body is **not** a SQL query. It is a template you write yourself, in HTML, with CSS for styling, JavaScript for interactivity, and [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) tokens to pull and shape live data. Whatever you write is what the report shows.

Start at **Reports** (`/reports`), click **New**, set output format to **HTML**.

## When to use it

HTML reports are the right tool for anything the data grid can't present:

* A **dashboard-in-a-page** with KPI cards, tabbed sections, conditional formatting.
* A **kanban-style board** rendered from a list of records.
* A **printable document** (statement, summary, profile) styled exactly the way you want.
* A **mini-app** that calls the saved data lookups, formats the results, and draws its own visuals.

Combined with [dashboard widgets](https://flexie.io/resources/dashboards/custom-html-widgets), HTML reports make almost any widget you can imagine possible: drop the HTML report in as a widget and the dashboard renders your custom layout.

## The report settings

Same as for [Data Grid reports](https://flexie.io/resources/reports/data-grid-reports#the-report-settings), except:

* **Output format** is set to **HTML**.
* **Query** is replaced by **Template**, the HTML body of the report. There is no row cap on the template field itself; rendering speed depends on the data lookups inside it (which **are** capped, see below).
* **Filters** can still be defined, but how they are applied is up to you (you read the submitted filter values inside your template).
* **Default order column** and **direction** do not apply to HTML reports.

## What you can write

Anything that renders in a browser:

* **HTML** for structure.
* **CSS** for styling, inline, in a `<style>` tag, or referenced.
* **JavaScript** for interactivity, inline `<script>` blocks or a `<script src>` reference to an external file.
* **Flexie Scripting** for data. Every function and filter listed in the [Flexie Scripting reference](https://flexie.io/resources/flexie-scripting/function-reference) is available inside the template.

A minimal example:

```html
<style>
  .card { padding: 1rem; border: 1px solid #eee; border-radius: 8px;
          background: #fff; margin-bottom: .75rem; }
  .num  { font-size: 2rem; font-weight: 600; color: #1a73e8; }
  .lbl  { font-size: .85rem; color: #555; text-transform: uppercase; }
</style>

<h2>This week at a glance</h2>

<div class="card">
  <div class="num">{{ findCount("deal", "is_won", 1) }}</div>
  <div class="lbl">Deals won (all-time)</div>
</div>

<div class="card">
  <div class="num">{{ findCount("case", "status", "open") }}</div>
  <div class="lbl">Open cases</div>
</div>

```

Open the report and you get two KPI cards backed by live data. The same idea scales up to a full custom page.

### Pull data, then weave it together

Because Flexie Scripting is available inside the template, you can run multiple lookups and combine them however you like:

```html
{% set winners = query("
  SELECT u.full_name, SUM(d.amount) AS total
  FROM deals d
  JOIN users u ON u.id = d.owner_id
  WHERE d.is_won = 1
  GROUP BY u.id
  ORDER BY total DESC
  LIMIT 10
") %}

<h2>Top closers</h2>
<ol>
  {% for row in winners %}
    <li>
      <strong>{{ row.full_name }}</strong> —
      {{ row.total | number_format(0) }}
    </li>
  {% endfor %}
</ol>

```

Or fetch a list of records and render them as cards, a table, a kanban: your choice.

### Loops, conditions, formatting

Everything you would expect from [Flexie Scripting basics](https://flexie.io/resources/flexie-scripting/language-basics) works:

```html
{% set deals = query("
  SELECT id, name, amount, is_won, is_lost
  FROM deals
  WHERE owner_id = {user_id}
  ORDER BY date_modified DESC
  LIMIT 50
") %}

<table>
  <thead><tr><th>Deal</th><th>Amount</th><th>Status</th></tr></thead>
  <tbody>
    {% for d in deals %}
      {% set status = d.is_won ? "Won" : (d.is_lost ? "Lost" : "Open") %}
      {% set colour = d.is_won ? "#0a8a3f" : (d.is_lost ? "#c32c2c" : "#888") %}
      <tr>
        <td>{{ d.name }}</td>
        <td>{{ d.amount | number_format(2) }}</td>
        <td style="color: {{ colour }}">{{ status }}</td>
      </tr>
    {% endfor %}
  </tbody>
</table>

```

The same placeholder variables that work in data grid queries (`{user_id}`, `{group_id}`, `{role_id}`, `{timezone}`) work inside `query(...)` calls within HTML reports.

## What the template can use

The full [Flexie Scripting toolkit](https://flexie.io/resources/flexie-scripting/function-reference) is available in HTML reports:

* **Data lookups**: `findOne`, `findMany`, `findCount`, `findSum`, `findMin`, `findMax`, `findDeals`, `findCases`, `findDealsValue`, `getSmartListRecords`, `getAccountContacts`, `getUserById`, `getOrganization`, `query` (read-only SQL).
* **Statistics bundles**: `getDealStats`, `getInvoiceStats`, `getCaseStats`.
* **Maths and formatting**: `add`, `subtract`, `multiply`, `divide`, `numberFormat`, `formatCurrency`, `round`.
* **Dates**: `date`, `now`, `dateAdd`, `dateSubtract`, `dateDiff`, `daysBetween`.
* **Text**: `truncate`, `htmlToText`, `startsWith`, `endsWith`, `urlEncode`, `md5`, `base64encode`.
* **Collections**: `sumField`, `avgField`, `minField`, `maxField`, `countDistinct`, `collectionColumn`, and the `group_by` / `sort_by` / `unique_by` / `sum_by` filters.
* **JSON**: `jsonDecode`, `jsonPath`.
* **Visual**: `qrCode`.

In short, everything a normal Flexie Scripting context can do is available, including the security helpers (`signUrl`, `jwtEncode`, `hashHmac`) for embedded actions and links.

## Restrictions still apply

HTML reports are powerful, but the underlying data lookups still play by the rules:

* **`query(...)` is read-only.** It accepts `SELECT` and `WITH`; it rejects `INSERT`, `UPDATE`, `DELETE`, `DROP`, `TRUNCATE`, `CREATE`, and `SELECT *`.
* **1,000-row cap** on every `findMany(...)`, `query(...)`, and similar data-returning function. Aggregate inside the call (`SUM`, `COUNT`, `GROUP BY`) if you need a number over a larger population.
* **Restricted tables** (system settings, attachments metadata, mailbox or SMTP credentials) are off-limits to `query(...)`, the same list as for data grid reports.
* **Only the documented Flexie Scripting functions, filters, and tags work.** See the [safety sandbox](https://flexie.io/resources/flexie-scripting/where-it-runs-and-limits#the-safety-sandbox).

## JavaScript and CSS, what runs and where

JavaScript and CSS in your template run in the **viewer's browser** like any other HTML page. There is no sandboxing on the rendered output. That means:

* Scripts can call your own back-end, third-party APIs, browser APIs, scoped by normal browser/CORS rules.
* Styles can be scoped to the report (use a wrapping class) or be global to the page (use careful selectors).
* The script runs **after** Flexie Scripting has resolved. `{{ }}` tokens are resolved server-side and the JavaScript sees the final values as literal strings or numbers.

### A common pattern, emit JSON, render with JS

```html
<div id="chart"></div>

<script>
  const data = {{ query("
    SELECT month, sales
    FROM monthly_sales
    WHERE year = 2026
    ORDER BY month
  ") | json_encode | raw }};

  data.forEach(row => {
    const bar = document.createElement("div");
    bar.style.width = row.sales / 1000 + "px";
    bar.textContent = row.month + ": " + row.sales;
    document.getElementById("chart").appendChild(bar);
  });
</script>

```

The `| json_encode | raw` chain turns the query result into a JSON literal embedded straight in the script.

> **Use `| json_encode` whenever you embed a value inside a `<script>` tag.** It quotes and escapes the data so a stray quote or newline in the data can't break your JavaScript or open an injection.

## Filters in HTML reports

Filters can still be defined on an HTML report, using the same JSON shape covered in [Report filters (in depth)](https://flexie.io/resources/reports/filters). Their submitted values land in the user's session, and your template reads them however you like.

In practice, HTML reports often use Flexie Scripting tokens directly inside their `query(...)` calls (via the same placeholders, `{user_id}`, `{group_id}`) rather than the `{filters}` substitution that data grid reports use. The richer rendering means you can also read filter values from the URL query string with `getQueryString("name")`.

## Security, what to keep in mind

Anyone who can **edit** an HTML report can place arbitrary HTML, CSS, and JavaScript in the rendered page. Anyone who can **view** the report runs that code in their browser. So:

* **Only give "edit reports" rights to trusted users.** A malicious or careless template can pull credentials from the viewer's browser, redirect them, or exfiltrate data. The [permissions model](https://flexie.io/resources/reports/viewing-exporting-sharing#access-control) controls this; keep the **Edit** permission tight.
* **Treat data interpolated into `<script>` blocks carefully.** Always pass it through `| json_encode` (and then `| raw` so the resulting JSON isn't re-escaped). For data inserted as visible HTML, prefer leaving the default escaping on (`{{ value }}` is already escaped); only use `| raw` when you truly mean "this is HTML".
* **Treat data interpolated into `href` / `src` carefully.** Use `| url_encode` for query-string values.

## Next steps

* [Viewing, exporting & access](https://flexie.io/resources/reports/viewing-exporting-sharing): the view page and permissions.
* [Reports as dashboard widgets](https://flexie.io/resources/dashboards/custom-html-widgets): how an HTML report becomes a fully custom widget.
* [Flexie Scripting reference](https://flexie.io/resources/flexie-scripting/function-reference): the toolbox your HTML template can use.

---

## Overview

Source: https://flexie.io/resources/reports/overview

# Overview

Last updated 25 May 2026

![A Flexie report producing both a data grid and a fully custom HTML page from the same saved query](https://flexie.io/image/resources/reports-overview.png)

A **report** in Flexie is a saved query plus a presentation. When someone opens it, Flexie runs the query, applies any user-supplied filters, and shows the result in one of two forms: a **data grid** (a sortable, filterable, exportable table) or a fully custom **HTML page** you wrote yourself.

## What a report turns into

A single report can be used as:

* An **operational list** ("all deals closing this month")
* An **aggregate number** ("revenue per salesperson, last 90 days")
* A **cross-record summary** ("top accounts by case volume")
* A **bespoke dashboards-in-a-page** (an HTML report can do anything HTML can do)
* A **data source for [dashboard widgets](https://flexie.io/resources/dashboards/report-widgets)**
* A **data source for [scripts and workflows](https://flexie.io/resources/reports/reports-in-workflows-and-widgets)**

There is no separate BI tool to learn; reports live alongside everything else.

## The two output formats

When you create a report you pick **one of two** output formats. This is the central decision and changes both what you write and what the report can do.

| Output format           | What you write                                | What gets rendered                      | When to use it                                                                                     |
| ----------------------- | --------------------------------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Data Grid** (default) | A SELECT query                                | A sortable, filterable, paginated table | Lists, exports, anything tabular                                                                   |
| **HTML**                | HTML + CSS + JavaScript with Flexie Scripting | Whatever you wrote, rendered as a page  | Fully custom layouts: cards, dashboards, kanban boards, anything you can build with web technology |

You can mix and match in your account: some reports are grids, others are fully bespoke HTML pages. They are stored in the same table and listed together.

> The output format is fixed for the life of the report. Once a report exists as a grid you can't flip it to HTML; create a new report if you need to switch.

## What every report has

Whether it is a grid or HTML, every report has:

* **Name, description, category**, for finding it later.
* **Output format**, `Data Grid` or `HTML`.
* **The body**, your query (for grid) or your template (for HTML).
* **Filters**, optional user-input controls shown above the report when someone opens it. See [Report filters (in depth)](https://flexie.io/resources/reports/filters).
* **Default sort**, which column to order by, ascending or descending.
* **Access list**, who can see it. Combinations of "all users", specific permissions, groups, or individual users.
* **Owner**, the user who created it (relevant for permission checks).

## The lifecycle of a report

1. **Create** at `/reports/new`, writing a query or HTML template.
2. **Open** at `/reports/view/{id}`. Sort, filter, paginate, export to CSV.
3. **Refine** the filters, sort, and columns and save.
4. **Reuse** as a dashboard widget, or query it from a script.

The data refreshes on every open, so there is no stale-cache surprise. Heavy queries are protected by a hard **1,000-row cap** (see [Restrictions](https://flexie.io/resources/reports/data-grid-reports#what-the-query-can-do-and-what-it-cant)).

## What is in this section

1. [Data Grid reports](https://flexie.io/resources/reports/data-grid-reports): writing the `SELECT`, the placeholder variables Flexie injects for you (`{user_id}`, `{group_id}`, `{role_id}`, `{timezone}`), the `{filters}` substitution, what queries are allowed and what is blocked, default sorting, and column ordering at view time.
2. [HTML reports](https://flexie.io/resources/reports/html-reports): building a fully custom report from HTML + CSS + JavaScript with Flexie Scripting; using the full Flexie Scripting toolkit inside the template; calling multiple data lookups and weaving the results together; the security model.
3. [Viewing, exporting & access](https://flexie.io/resources/reports/viewing-exporting-sharing): the view page, sorting and pagination, **CSV export**, and the "Who can access this report?" permission model.
4. [Reports in workflows and dashboards](https://flexie.io/resources/reports/reports-in-workflows-and-widgets): using a saved report as a **dashboard widget** (with six visualisation subtypes), pulling its data from a Flexie Scripting context, and the `getReportData(...)` accessor.
5. [Report filters (in depth)](https://flexie.io/resources/reports/filters): user-input filters above the grid. The JSON shape, the six filter types and their operators, the three substitution modes (`{filters}` placeholder, automatic, and `manual`), and, uniquely, **using Flexie Scripting _inside_ the filter JSON** to build dynamic option lists, conditional filters, and date-aware labels.

## Closely related

* [Dashboards](https://flexie.io/resources/dashboards/overview): collections of widgets, where most reports end up being displayed.
* [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview): the language you use inside HTML reports.
* [Workflows](https://flexie.io/resources/workflows/overview): workflows can pull values from saved reports.

---

## Reports in Workflows & Dashboards

Source: https://flexie.io/resources/reports/reports-in-workflows-and-widgets

# Reports in Workflows & Dashboards

Last updated 25 May 2026

![A saved Flexie report feeding a dashboard widget, an HTML report, a workflow step, and an external API caller](https://flexie.io/image/resources/reports-reports-in-workflows-and-widgets.png)

A saved report is not only viewed on its own page. It is also a **data source** for dashboards, for HTML reports, for workflow steps, and (via the API) for outside systems.

## A report as a dashboard widget

The most common second life for a saved report is becoming a widget on a [dashboard](https://flexie.io/resources/dashboards/overview). Every **published** report automatically becomes available as a widget type. You don't have to do anything special. Add a widget to a dashboard, pick the report, and choose how it should render.

A report widget can be displayed in any of six ways:

* **Single value**: pull one cell from one column for a big-number tile.
* **Single number**: alias for Single value.
* **Line chart**: plot two columns as X and Y.
* **Bar chart**: plot two columns as category and value.
* **Pie chart**: plot two columns as label and slice value.
* **Grid**: the report's full result as a small table inside the widget.

The full configuration (axes, label or value columns, single-value column, optional limit) is covered in [Report widgets](https://flexie.io/resources/dashboards/report-widgets).

### What kinds of reports work as widgets

* **Data Grid reports** work as Grid, Line, Bar, Pie, or Single value widgets. The report's query is the data source; the widget configures how it is rendered.
* **HTML reports** work as **custom HTML widgets**. The whole rendered template appears as the widget contents. See [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets). This is the "any imaginable widget" route.

## Pulling a report's data from a Flexie Scripting context

If you want to use a report's data _inside_ something else (an HTML report that combines multiple reports, an email template, an automation step) you can call the saved report's data with the `getReportData(...)` function.

> The exact availability of `getReportData(...)` depends on which Flexie Scripting context you are in. It is available **inside HTML reports** and the report-render path. If you call it from a general workflow action and find it isn't recognised, fall back to writing the equivalent `query("SELECT ...")` in your script; `query(...)` works everywhere [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview) runs.

### Signature

```
getReportData(reportId, userId?, filters?, templateData?)

```

| Argument     | Meaning                                                                                                                                                                      |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| reportId     | The numeric id of a saved report.                                                                                                                                            |
| userId       | Optional. If provided, the report's placeholder variables ({user\_id}, {group\_id}, {role\_id}, {timezone}) are resolved against _that_ user rather than the signed-in user. |
| filters      | Optional. An array of { alias, operator, value } objects, programmatic equivalents of what a user would fill into the report's filter row.                                   |
| templateData | Optional. Extra Flexie Scripting tokens you want resolved inside the report's query before it runs.                                                                          |

The function returns an array of rows, the same shape as the data grid would show; each row is a key-value map of column names to values. **Capped at 1,000 rows**, same as everything else.

### Using it inside an HTML report

The simplest pattern, re-use an existing aggregated report as a data feed:

```
{% set rows = getReportData(42) %}

<table>
  <tr><th>Owner</th><th>Total won</th></tr>
  {% for r in rows %}
    <tr><td>{{ r.owner_name }}</td><td>{{ r.total | number_format(0) }}</td></tr>
  {% endfor %}
</table>

```

…assuming report `42` is a saved data grid report whose query produces `owner_name` and `total` columns.

### Applying filters programmatically

```
{% set rows = getReportData(
    42,
    user_id,
    [
      { "alias": "status",  "operator": "eq", "value": "finalized" },
      { "alias": "country", "operator": "eq", "value": "DE" }
    ]
) %}

```

The filter aliases are the same as those defined in the saved report's [filters JSON](https://flexie.io/resources/reports/filters).

## Workflows reading a saved report

Workflows reach reports two ways.

### Inside a workflow action's Flexie Scripting fields

Any step's value, template, or condition fields are Flexie Scripting. You can pull report data there with `query(...)` and act on it.

```
{# Compute today's pipeline value for the contact's owner #}
{% set rows = query("
  SELECT SUM(amount) AS total
  FROM deals
  WHERE owner_id = " ~ owner_id ~ "
    AND is_won = 0 AND is_lost = 0
") %}

{% set pipelineValue = rows[0].total | default(0) %}

```

This isn't strictly using a _saved_ report; it is running an ad-hoc query. But the same access functions are available.

### Calling the API from a webhook

A workflow's **Webhook** action can call your own back-end, which in turn hits `/api/reports/{id}/data`. Useful if the report does something complex you don't want to recompute inline.

## Reports as a feed for other systems

Outside systems can read a report through the API:

* `GET /api/reports/{id}/data` returns the report's rows.
* Pass filter values as query parameters to apply them.
* The 1,000-row cap and the read-only restrictions still apply.

Use this when another team or a partner needs a snapshot of your data: they authenticate with a Flexie API token, pull the report's rows, and load them into their own system.

## Patterns that come up a lot

### A KPI feed for an external dashboard

1. Build a small **data grid** report: one row, a handful of columns. `SELECT (count_query) AS deals, (sum_query) AS pipeline, ...`.
2. Mark the report as **published** and give it a stable id.
3. Have the external dashboard call `/api/reports/{id}/data` on its refresh cycle.

### A bigger report feeding multiple smaller widgets

1. Build one **data grid** report that produces all the columns you would ever need (for example `owner_id, owner_name, won_count, won_total, open_count`).
2. Add it to a dashboard as five different widgets: Single value for each metric, Bar chart for the ranking.
3. Every widget shares one query, one data source, one update. Fast and consistent.

### An HTML report that combines multiple sources

1. Build an **HTML report** that calls `query(...)` (or `getReportData(...)`) multiple times for the different sections of a single page.
2. Render the results as your own custom layout: KPI cards across the top, tables in the middle, a chart at the bottom.
3. Drop that HTML report on a dashboard as a custom HTML widget. See [Custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets).

## Next steps

* [Dashboards](https://flexie.io/resources/dashboards/overview): where reports usually end up.
* [Dashboards: report widgets](https://flexie.io/resources/dashboards/report-widgets): the six visualisation subtypes in detail.
* [Dashboards: custom HTML widgets](https://flexie.io/resources/dashboards/custom-html-widgets): using an HTML report as a fully custom widget.

---

## Viewing, Exporting & Access

Source: https://flexie.io/resources/reports/viewing-exporting-sharing

# Viewing, Exporting & Access

Last updated 25 May 2026

![A Flexie report view page with sortable columns, a CSV export button, and the Who can access this report field](https://flexie.io/image/resources/reports-viewing-exporting-sharing.png)

A saved report is opened at **`/reports/view/{id}`**. What you see depends on the report's [output format](https://flexie.io/resources/reports/overview#the-two-output-formats):

* **Data Grid**: header bar, filter row, paginated table, sort by clicking column headers, page-size selector, **Export** button.
* **HTML**: the rendered template, with whatever interactivity its CSS or JavaScript adds on top.

## The view page (data grid)

For data grid reports the user controls behave as follows.

### Sorting

Click any column header to sort by that column. Click again to reverse the direction. The current sort is **remembered per user, per report**. When the user comes back, their last sort is restored.

If the user hasn't sorted yet, the **default sort** from the report's settings applies.

### Filters

If the report defines [user-input filters](https://flexie.io/resources/reports/filters), they appear above the grid. Submitting them re-runs the query with the filter values applied (via the `{filters}` substitution or, in [manual mode](https://flexie.io/resources/reports/filters#mode-3-manual-mode-filter-values-as-scripting-variables), via Flexie Scripting inside the query).

Active filters are **remembered per user, per report**, same as sorting.

### Pagination

A page-size selector lets the user choose how many rows per page. Below the grid is a standard page navigator. The full 1,000-row result is paginated client-side once retrieved.

> If your data set frequently bumps against the 1,000-row cap, that is a sign the report should be aggregated (a `GROUP BY`) rather than a flat list. See [Performance tips](https://flexie.io/resources/reports/data-grid-reports#performance-tips).

## Exporting to CSV

Every data grid report has an **Export** action that produces a CSV download of the full result. The export URL is `/reports/view/{id}/export`; clicking Export sends the user there.

### What the CSV contains

* A **header row** with the column names from your query.
* One row per result, exported in chunks until the full result set is sent (streamed to the browser as it is generated, so the download starts straight away even for the full 1,000 rows).
* The **current filters, sort, and user-context placeholders** are all applied. Exports respect whatever filters the user has set, and they produce the same data the on-screen grid is showing.

### Filename

The exported file is named:

```
<report-name>_<YYYY-MM-DD_HH:mm:ss>.csv

```

…so it is safe to re-export and keep both files without renaming.

### Audit log

Every export is recorded in the audit log with the user, the report, the filters used, and the timestamp. This matters when the report contains personal data, see [Compliance](#compliance-and-privacy) below.

### HTML reports don't have CSV export

HTML reports are pages, not tables; there is nothing rectangular to export. If you need both, build a data grid report for the export and an HTML report for the presentation, and have them share a saved data source.

## Access control

A report is gated by **two layers** that both have to pass: the role-level **report permissions** the user has, and the per-report **"Who can access this report?"** list the maintainer sets on the report itself.

### Role-level permissions

Flexie's [role system](https://flexie.io/resources/security/accounts-and-security) carries a set of report permissions an admin assigns to each role. Each one comes in two scopes, **own** (only the user's own reports) and **all** (everyone's), plus a **full** option that bundles everything:

| Permission | What it grants                                                                  |
| ---------- | ------------------------------------------------------------------------------- |
| **View**   | Open reports and see their results, scoped to the user's own or to all reports. |
| **Create** | Create new reports.                                                             |
| **Edit**   | Change a report's query, template, filters, or settings. Scoped to own or all.  |
| **Delete** | Remove a report. Scoped to own or all.                                          |
| **Full**   | Everything above. Effectively the reports admin.                                |

A user needs at least the **View** permission (in either scope) to use the Reports area at all.

### "Who can access this report?"

On each report's settings page there is a single multi-select field, **Who can access this report?**, that decides who is allowed to open _this specific report_. You add entries from four kinds:

* **All Users**: everyone with a "view" report permission can see it.
* **Permissions**: a role (e.g. _Admissions Manager_, _Spa Manager_). Anyone whose role is in the list can see it.
* **Groups**: a user group. Members of the group can see it.
* **Users**: a specific person.

You can mix kinds in one report. A viewer is allowed in if they match **at least one** entry. An empty list means the report has no audience (only an admin with the Full permission can still open it).

### Putting the two together

| Role permission      | "Who can access" match   | What happens                             |
| -------------------- | ------------------------ | ---------------------------------------- |
| Full                 | (irrelevant)             | Allowed                                  |
| View all             | (irrelevant)             | Allowed                                  |
| View own             | The user owns the report | Allowed                                  |
| View own             | The user doesn't own it  | Allowed only if they also match an entry |
| (no view permission) | (irrelevant)             | Reports area is hidden entirely          |

> **HTML reports are powerful.** They can run arbitrary JavaScript in the viewer's browser. Be mindful when granting **Edit** rights: that permission lets a user place arbitrary code in pages that other users see.

## API access

A report can be read programmatically by another system through the API (authentication: a Flexie API token).

| Endpoint                   | Returns                                                                                 |
| -------------------------- | --------------------------------------------------------------------------------------- |
| GET /api/reports           | The list of reports the caller has access to.                                           |
| GET /api/reports/{id}      | The metadata of one report.                                                             |
| GET /api/reports/{id}/data | The **rows** the report would produce, applying any filters passed as query parameters. |

For workflows and HTML reports, the equivalent in-Flexie access is the `getReportData(...)` lookup. See [Reports in workflows and widgets](https://flexie.io/resources/reports/reports-in-workflows-and-widgets).

## Compliance and privacy

A report can hold or surface personal data. A few things worth knowing:

* **Exports are logged.** Every CSV download is recorded with the user, the report, the active filters, and the time. If you are handling subject-access requests, this gives you the trail.
* **Filters are per-user**, kept in the user's session. A user can't see another user's filter set; one user picking a "Country = Germany" filter doesn't change anyone else's view.
* **Placeholders enforce context.** A report that filters on `{user_id}` inherently scopes itself to the signed-in user. Combine that with a "view own" permission to publish a report where everyone sees only their own row.
* **Restrict who can edit HTML reports.** See the note in [Access control](#access-control).

## Next steps

* [Reports in workflows and dashboards](https://flexie.io/resources/reports/reports-in-workflows-and-widgets): using a saved report's data from other places.
* [Dashboards](https://flexie.io/resources/dashboards/overview): most reports end up on a dashboard.

---

## Accounts, Teams & Security

Source: https://flexie.io/resources/security/accounts-and-security

# Accounts, Teams & Security

Last updated 23 May 2026

![A Flexie account with team members holding different roles, each with their own scope of access](https://flexie.io/image/resources/security-accounts-and-security.png)

Flexie is built for teams. Everyone you invite shares the same customers, deals, inbox, and data, but each person sees and does only what their role allows. To add someone, invite them by email. They get their own sign-in and join your shared workspace.

## Roles and permissions

A **role** decides what a team member can see and do. This is how you keep sensitive information in the right hands while still letting everyone do their job.

You set up roles to match how your business works, and assign each person the role that fits. When you change a role, the change takes effect immediately, no need for anyone to sign out and back in.

## Ownership of records

Most records in Flexie, customers, deals, cases, can have an **owner**: the team member responsible for them. Ownership keeps accountability clear and lets you control who works on what. Combined with roles, it means people see the records that are theirs to handle.

## Secure sign-in

Flexie protects every account with secure sign-in. For extra protection, signing in can be confirmed with a **one-time code**, a short code that must be entered to complete the login. Even if someone learns a password, they still cannot get in without that second step. It is strong protection that stays simple for your team to use.

## The activity record

Flexie keeps a record of the important things that happen in your account, who changed what, and when. If you ever need to check back, the history is there. It is accountability built into the platform.

## Connections and outside access

When you connect Flexie to another tool or to an AI assistant, that connection is protected and limited to exactly what you allow. You can review every connection and switch any of them off at any time. See [Integrations & Developer Access](https://flexie.io/resources/integrations/integrations-and-api).

## Flexie AI plays by the same rules

Flexie AI follows the same permissions as your team. It can only do what the account allows, and before it makes any important change, it asks for approval first. See [Flexie AI](https://flexie.io/resources/ai/overview).

## Your data is yours

The information you put into Flexie belongs to you. You can work with it, export it, and decide who has access to it. Flexie is the home for your business data, not the owner of it.

## Good security habits

A few simple practices keep your account safe:

* Give each person their **own** sign-in. Never share logins.
* Use **roles** so people have only the access they need.
* Turn on the **one-time code** sign-in for everyone.
* Remove access promptly when someone leaves the team.
* Review your **connections** to outside tools from time to time.

## Just ask Flexie AI

* "Who has admin access on this account?"
* "Show me what changed on this deal last week and by whom."
* "Remove access for someone who has left the team."

See [Flexie AI](https://flexie.io/resources/ai/overview).

## Next steps

* [Getting Started](https://flexie.io/resources/getting-started/introduction): set up your account and team.
* [Integrations & Developer Access](https://flexie.io/resources/integrations/integrations-and-api): manage outside access.
* [Flexie AI](https://flexie.io/resources/ai/overview): see how the AI respects your permissions.

---

## Actions & Decisions

Source: https://flexie.io/resources/workflows/actions-and-decisions

# Actions & Decisions

Last updated 23 May 2026

![A workflow step that splits into a Yes branch and a No branch through a decision diamond](https://flexie.io/image/resources/workflows-actions-and-decisions.png)

You add these on the builder canvas. Actions perform side effects. Decisions split the path into a **Yes** branch and a **No** branch. This page is the catalogue and the rules.

## Actions: the steps that do work

An action performs one side effect and then lets the workflow continue. The available actions are grouped by area; the common ones:

### Communication

* **Send an email** using a template or composed inline, with attachments.
* **Send an SMS**.
* **Send a WhatsApp message** to numbers you already have an inbound message from.
* **Notify a user**: push an on-screen notification, or redirect a signed-in user.

### Records

* **Create a record**: a new lead, contact, deal, case, invoice, task, note, or custom record. The new record's id becomes available to later steps, see [Passing data](https://flexie.io/resources/workflows/passing-data-between-steps).
* **Update a record**: change fields, stage, owner, or tags. Changing a deal's stage to a won or lost stage sets the won/lost flags correctly.
* **Create a task** or **add a note**.
* **Process child records**: push records related to the current one into a target workflow.
* **Delete child records**: remove related records (no undo, it is logged to the audit trail).

### Documents

* **Generate a PDF** for an invoice or quote document.
* **Work with attachments**: copy or attach files.

### Logic and integration

* **Call a webhook**: send an HTTP request to another system, with a body you compose in [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview). Can be set to retry on failure, see below.
* **Store a value**: save a computed value so later steps can use it (`{{ __data.… }}`).
* **Set shared memory**: store a value in short-lived shared memory that other workflows can read with `memoryGet(...)`.
* **Move to another workflow**: remove the record from this workflow and/or add it to a different one.
* **An AI step**: hand Flexie AI a job in plain words ("review this deal and flag risks," "draft a reply"), and it does that job, unattended, every time the workflow runs. See [Flexie AI](https://flexie.io/resources/ai/overview).

> The exact set of actions you see depends on the record type and on which features are enabled for your account.

## How an action's result steers the flow

Every action either **succeeds** or **fails**, and that result routes what runs next:

* **Success → the "Yes" path.** Steps connected to the action run.
* **Failure → the "No" path.** If the action has a separate failure branch, it takes that; otherwise the branch stops there.

### When an action fails

By default a failed action stops its branch (and is recorded as failed in the [activity logs](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting)). For best-effort steps whose failure should not halt everything (an optional notification, a non-critical enrichment), you can set the action to **ignore failure**: the branch then continues as if it had succeeded, while the failure is still recorded for visibility.

> Ignore-failure is for "nice to have" steps. It is **not** a retry, and it is not for steps that later steps depend on.

### Retries

The workflow engine does **not** retry steps automatically. A few actions implement their own retry where it is safe to do so, most notably the **Webhook** action, which you can tell to retry a failed request a set number of times. For everything else, a step runs once; if it fails it is logged and the branch follows the failure path. (Email sending has its own delivery-level retry, separate from the workflow.)

## Decisions: the steps that choose

A **decision** checks a condition and routes the record down either its **Yes** branch or its **No** branch. There are four kinds, each suited to a different thing to check:

| Decision              | Checks…                                                                                                   | Use it for                                                                                                                 |
| --------------------- | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| **Record condition**  | the current record's field values                                                                         | "is this deal over 10,000?", "is the contact in Germany?"                                                                  |
| **Time condition**    | the current date and time                                                                                 | "is it a weekday?", "is it after 9am?", "is it January?"                                                                   |
| **Virtual condition** | values under \_\_data, anything an earlier step stored, or any field carried in by an inbound web request | branching on a webhook payload or a stored value, see [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/virtual-conditions) |
| **Core decision**     | a general condition                                                                                       | a simpler variant of the record condition                                                                                  |

### Record conditions: building the filter

A record condition uses the same **filter builder** you will recognise from smart lists: pick a field, an operator, and a value. You can combine several rules with **AND** and **OR**, and nest groups.

#### The full operator catalogue

| Operator                                 | Meaning                                                                                             |
| ---------------------------------------- | --------------------------------------------------------------------------------------------------- |
| equal / not\_equal                       | Value matches / does not match                                                                      |
| less / less\_or\_equal                   | Less than / less than or equal to                                                                   |
| greater / greater\_or\_equal             | Greater than / greater than or equal to                                                             |
| less\_than\_now / greater\_than\_now     | A datetime field compared to the current moment                                                     |
| less\_than\_today / greater\_than\_today | A date field compared to today                                                                      |
| between / not\_between                   | Falls inside / outside a range (you give the two endpoints)                                         |
| begins\_with / not\_begins\_with         | Text starts / does not start with the value                                                         |
| ends\_with / not\_ends\_with             | Text ends / does not end with the value                                                             |
| contains / not\_contains                 | Text includes / does not include the value                                                          |
| in / not\_in                             | Value is one of / is not one of a comma-separated list                                              |
| in\_list / not\_in\_list                 | Record is in / is not in a saved smart list                                                         |
| includes / excludes                      | For multi-value fields (tags, multi-select), at least one of / none of the chosen values is present |
| is\_empty / is\_not\_empty               | Field is blank / has a value                                                                        |
| is\_null / is\_not\_null                 | Field is NULL / is not NULL (subtly different from empty for some field types)                      |
| is\_subscribed / is\_not\_subscribed     | Record is / is not subscribed (for fields linked to subscriptions)                                  |
| is / is\_not                             | A **named relative window**, see the table below                                                    |
| in\_polygon                              | A point field falls inside a polygon shape (geographic filtering)                                   |

> **Valueless operators still need a value key.** For `is_empty`, `is_not_empty`, `is_null`, `is_not_null`, the filter builder sets the value to "none" automatically. You just pick the operator.

#### Relative date windows: `is` and `is_not`

When you choose the `is` or `is_not` operator on a date or datetime field, you pick from a list of named windows. All windows are evaluated **in your account's timezone**:

| Resolution      | Available values                                                                           |
| --------------- | ------------------------------------------------------------------------------------------ |
| Day             | today, yesterday, next\_day, birthday\_today                                               |
| Hour (datetime) | last\_hour, last\_12\_hours, last\_24\_hours, next\_hour, next\_12\_hours, next\_24\_hours |
| Week            | this\_week, last\_week, next\_week                                                         |
| Month           | this\_month, last\_month, next\_month                                                      |
| Quarter         | this\_quarter, last\_quarter, next\_quarter                                                |
| Year            | this\_year, last\_year, next\_year                                                         |
| Rolling past    | last\_7\_days, last\_14\_days, last\_30\_days, last\_60\_days, last\_90\_days              |
| Rolling future  | next\_7\_days, next\_14\_days, next\_30\_days, next\_60\_days, next\_90\_days              |

`birthday_today` matches **regardless of year** (it compares the month and day), which is how you build "birthday today" automations.

### Time conditions

A time condition compares the **current moment** against rules you set. There are **seven** time fields to choose from, each one a different slice of "now":

| Field      | What it is at evaluation time                                   |
| ---------- | --------------------------------------------------------------- |
| full\_date | The current date and time (Y-m-d H:i:s)                         |
| date\_only | Today's date (Y-m-d)                                            |
| time\_only | The current time                                                |
| year       | The current year as a number                                    |
| month      | The current month as a lower-case name (january, ..., december) |
| date       | The current day-of-month as a number (1 to 31)                  |
| day        | The current weekday as a lower-case name (monday, ..., sunday)  |

Combine these with the same operators as record conditions (`equal`, `between`, `is_empty`, etc.). For example **"only continue Mon to Fri between 09:00 and 17:00"** is a time condition with two rules joined by **AND**.

**Time ranges that cross midnight** (e.g. `between 23:00:00 and 06:00:00`) are handled correctly. The engine treats them as a wrap-around window covering both sides of midnight rather than an empty range.

> If you need a step (rather than a whole branch) to be limited to a window or day, use the step's own **restricted hours and skip days** setting instead, it is lighter than a full decision. See [Scheduling](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

### Virtual conditions

A virtual condition compares values that are not stored fields, data that arrived with the trigger or that an earlier step produced, addressed with `{{ __data.… }}`. This is the decision type you use in dynamic-endpoint workflows. Because its setup is specific, it has its own page: [Virtual conditions](https://flexie.io/resources/dynamic-endpoints/virtual-conditions).

> **Every decision must have its branches connected.** Attach the steps that should run on **Yes** to the Yes branch, and the steps for **No** to the No branch. A step left off both branches never runs.

## Listeners as mid-workflow gates

A **listener** placed inside a workflow pauses its branch until an external signal arrives. For instance, **send an email, then wait for it to be opened** before continuing. When the signal comes, the branch resumes and the signal's data is available to the steps that follow. Listeners as the **start** of a workflow are covered in [Triggers & sources](https://flexie.io/resources/workflows/triggers-and-sources).

### The listener catalogue

The available listeners, grouped by area, and where each is meaningful (at the start of a workflow, mid-tree after an earlier step, or both):

| Area               | Listener                                 | Where it can sit                                                                                |
| ------------------ | ---------------------------------------- | ----------------------------------------------------------------------------------------------- |
| **Email**          | An email is opened                       | Mid-tree, after a step that sent the email                                                      |
|                    | A link in an email is clicked            | Mid-tree, after a step that sent the email                                                      |
|                    | An email replies                         | Mid-tree                                                                                        |
|                    | An email bounces or fails                | Mid-tree                                                                                        |
|                    | An attachment is downloaded              | Mid-tree                                                                                        |
| **Mailbox**        | An email arrives in a connected mailbox  | Start (a \_\_virtual workflow)                                                                  |
| **SMS / WhatsApp** | An SMS or WhatsApp message is received   | Start                                                                                           |
|                    | An SMS or WhatsApp message is delivered  | Start or mid-tree                                                                               |
| **Forms**          | A form is submitted                      | Start, see [Forms](https://flexie.io/resources/forms/overview)                                                   |
| **Notes & tasks**  | A new task is created                    | Start                                                                                           |
|                    | A task is updated                        | Start                                                                                           |
|                    | A new note is added                      | Start                                                                                           |
|                    | A new comment is added to a note         | Start                                                                                           |
|                    | A user is mentioned in a note or comment | Start                                                                                           |
| **Pages / links**  | A tracked page is visited                | Start                                                                                           |
| **Virtual entity** | A web request hits a dynamic endpoint    | Start of a \_\_virtual workflow, see [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview) |

Some listeners (notably **email opened**, **link clicked**, and **attachment downloaded**) only make sense **after an email has been sent earlier in the same workflow**, so the builder only offers them as mid-tree steps. The rest can either start a workflow or sit inside one.

Each listener writes its signal's data into the workflow's `__data` notepad under a specific alias, see the full payload reference in [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps).

## Next steps

* [Runtime, parallel execution & the tree](https://flexie.io/resources/workflows/runtime-parallel-and-tree): how these steps actually run.
* [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps): feeding each step from the ones before it.

---

## Building a Workflow

Source: https://flexie.io/resources/workflows/building-a-workflow

# Building a Workflow

Last updated 23 May 2026

![A Flexie workflow builder canvas with a trigger, two actions, and a decision branching into Yes and No paths](https://flexie.io/image/resources/workflows-building-a-workflow.png)

From an empty canvas to a live automation: a trigger, the steps that branch off it, and the moment you flip the switch. The [Workflows overview](https://flexie.io/resources/workflows/overview) covers the building blocks assumed below if you have not read it yet.

## Step 1: Create the workflow

From the Workflows list inside your Flexie account, choose **New**. You set the basics:

| Setting         | What it means                                                                                                                                                                                 |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**        | A clear name you will recognise in the list. Required.                                                                                                                                        |
| **Description** | Optional notes on what it does and why.                                                                                                                                                       |
| **Record type** | The kind of record this workflow runs on: Lead, Contact, Account, Deal, Case, Invoice, a custom record type, etc. This is fixed once the workflow has steps, so choose deliberately.          |
| **Category**    | Optional grouping for the list.                                                                                                                                                               |
| **Run mode**    | **Async** (the default, background) or **Sync** (immediate). Explained in [Runtime](https://flexie.io/resources/workflows/runtime-parallel-and-tree). Leave it on **Async** unless you have a specific reason. |

The **source**, what actually triggers the workflow, is covered in [Triggers & sources](https://flexie.io/resources/workflows/triggers-and-sources). You pick this as part of setup.

## Step 2: The builder canvas

Once created, the workflow opens in the **visual builder**: a canvas where the trigger sits at the top and steps flow downward. You build by adding blocks and connecting them.

There are three things you place:

* **Actions** that **do** something.
* **Decisions** that **check** something and split into a Yes path and a No path.
* **Listeners** that **wait** for an external signal before continuing.

See [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions) for the full catalogue and how each is configured.

## Step 3: Connect steps into a tree

This is the part that makes a workflow more than a checklist. **Every step you add is connected to a parent step**, and execution flows along those connections. The result is a tree:

Two rules govern the tree, and they matter:

* **A decision's children belong to a branch.** When you connect a step beneath a decision, you attach it to the **Yes** path or the **No** path. A child left unattached to either branch will never run. Always make the branch explicit.
* **An action's children just follow it.** Steps connected beneath an action run after it. For steps that can fail, the failure can route to a different child, see [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions).

You can place **more than one step directly under the same parent**. They are siblings, and they can run **at the same time**, see [parallel execution](https://flexie.io/resources/workflows/runtime-parallel-and-tree).

> The builder prevents loops (a step cannot eventually lead back to itself) and warns if a step is not connected to anything. If you leave a step dangling, it is attached to the previous step automatically and you will see a notice.

## Step 4: Configure each step

Click a step to open its settings. Most fields accept [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview), so a value can be computed from the record and from data earlier steps produced, for example the recipient address, the body of a message, or the value to write to a field. Data from the trigger and earlier steps is available as `{{ __data.… }}`. See [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps).

Each step can also have **timing**: run immediately, after a delay, or at a set date. And it can be restricted to certain hours or days. See [Scheduling](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## Step 5: Test before going live

Do not publish blind. Use the built-in **test run** to execute the workflow against a single real record and see exactly what each step **would** do, with a log of the outcome of every step. This is covered in [Testing](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## Step 6: Publish

A workflow only runs when it is **published**. Publishing is a toggle on the workflow. You can also set a **publish window**: a start date and time and an optional end date and time, so the workflow is only active during that period. Outside the window it is dormant, even if otherwise published.

## The lifecycle at a glance

* **Editing a live workflow** is allowed. Each save creates a new **version**, so you can review history and roll back. See [Versions & rollback](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).
* **Unpublishing** stops new runs. Records already partway through finish according to how the engine had already scheduled them.

## Next steps

* [Triggers & sources](https://flexie.io/resources/workflows/triggers-and-sources): choose what starts your workflow.
* [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions): the steps you place on the canvas.

---

## Overview

Source: https://flexie.io/resources/workflows/overview

# Overview

Last updated 23 May 2026

![A Flexie workflow tree with a trigger at the top and steps branching down into actions, decisions, and listeners](https://flexie.io/image/resources/workflows-overview.png)

This section is the complete guide to Flexie's automation engine: what a workflow is, how it's built, how it runs, and how to make it do real work reliably.

## What a workflow is

A **workflow** is an automation you set up once and Flexie then runs for you. At its heart is a single idea:

> **When something happens, do a series of things, and make smart choices along the way.**

A workflow is built as a **tree of steps**. Something triggers it (a record changes, a message arrives, a schedule fires), and from there execution flows down through the steps you have connected, branching left or right at each decision.

## The four building blocks

Every workflow has four kinds of building block. Understanding these four is the key to everything else.

| Block                | What it is                                                                                                | What it returns or does                            |
| -------------------- | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| **Trigger / Source** | What makes the workflow run, and on which kind of record.                                                 | Starts the run for one or more records.            |
| **Action**           | A step that **does** something: send a message, create or update a record, call a webhook, store a value. | Succeeds or fails, which can route the next steps. |
| **Decision**         | A step that **checks** something and splits the path into a **Yes** branch and a **No** branch.           | Yes or No.                                         |
| **Listener**         | A step that waits for an external signal (an email opens, a reply arrives) before its branch continues.   | Resumes its branch when the signal fires.          |

Actions and decisions are connected into a **tree**: each step has a parent, and a decision's children are tagged as belonging to its Yes branch or its No branch. How that tree is walked, and how independent branches can run at the same time, is covered in [Runtime, parallel execution & the tree](https://flexie.io/resources/workflows/runtime-parallel-and-tree).

## A worked example, in words

> **Trigger:** a deal moves to the "Won" stage. **Action:** create an onboarding task for the account manager. **Decision:** is the deal value over 10,000? **Yes:** notify the head of delivery, and send a premium welcome email. **No:** send the standard welcome email. **Action (both branches):** add the tag `onboarding`.

That is a workflow: one trigger, a few actions, one decision with two branches.

## The two ways to build one

1. **The visual builder.** Open the Workflows section in your Flexie account, create a new one, and assemble the trigger, actions, and decisions on a canvas by adding blocks and connecting them. This is the hands-on way and is what most of this section documents.
2. **Ask Flexie AI.** Describe the automation in plain words and Flexie AI builds the whole tree for you, ready to review and switch on. See [Flexie AI](https://flexie.io/resources/ai/overview). Everything the AI builds is an ordinary workflow you can then open and edit in the builder.

## What this section covers

1. [Building a workflow](https://flexie.io/resources/workflows/building-a-workflow): the canvas, adding and connecting steps, saving, publishing, and the lifecycle of a workflow.
2. [Triggers & sources](https://flexie.io/resources/workflows/triggers-and-sources): the five ways a workflow can start, and choosing the right one.
3. [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions): the step types, the decision conditions, the Yes/No branching, and how failures are handled.
4. [Runtime, parallel execution & the tree](https://flexie.io/resources/workflows/runtime-parallel-and-tree): how the tree is walked, immediate vs background running, and how independent branches run in parallel.
5. [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps): the `__data` namespace, how each step can use what earlier steps and the trigger produced.
6. [Scheduling, testing & troubleshooting](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting): delays, time windows, throttling, the test run, the activity logs, versions, and the common pitfalls.

> **Closely related:** [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview) are workflows triggered by an incoming web request and built on a "virtual" record. They are a kind of workflow, documented separately because they are a topic in themselves.

## Who should read what

* **End users and builders:** start with **Building a workflow** and **Triggers & sources**, then **Actions & decisions**.
* **Administrators and power users:** also read **Runtime**, **Passing data**, and **Scheduling & troubleshooting**. These explain the behaviour that determines whether a busy workflow is fast, correct, and safe.

## Next steps

* [Building a workflow](https://flexie.io/resources/workflows/building-a-workflow): step by step, from an empty canvas to a live automation.
* [Triggers & sources](https://flexie.io/resources/workflows/triggers-and-sources): the five ways a workflow can start.
* [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions): the building blocks each step is made of.

---

## Passing Data Between Steps

Source: https://flexie.io/resources/workflows/passing-data-between-steps

# Passing Data Between Steps

Last updated 23 May 2026

![The __data notepad in a workflow, written by earlier steps and read by later steps](https://flexie.io/image/resources/workflows-passing-data-between-steps.png)

As a workflow runs, it gathers information: the data the trigger carried, values earlier steps computed, the ids of records it created, replies from webhooks. All of it is collected in one place, a shared namespace called **`__data`**, and any **later** step can read it with [Flexie Scripting](https://flexie.io/resources/flexie-scripting/overview):

```
{{ __data.incoming_email.subject }}
{{ __data.__entity_inserted_id }}
{{ __data.my_stored_value }}

```

Think of `__data` as a notepad that every step in the run can read, and that specific steps write to. It is scoped to **this workflow, for this record**. There is no leakage between records or between workflows, and within a run there is no expiry: anything written stays available to everything downstream.

> **One rule that ties back to the [tree](https://flexie.io/resources/workflows/runtime-parallel-and-tree):** a step can only rely on data that was produced **above it** in the tree. If step B needs what step A produced, B must be a **descendant** of A, not a sibling running alongside it.

## What writes into `__data`

### 1\. The trigger or listener signal

When a workflow starts from a **listener**, the signal's data is placed into `__data` before the first step runs. So the very first action can already use it. The common signals and what they provide:

| Trigger signal                        | Read it as                                                                           | Useful fields                                                                         |
| ------------------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
| An email arrives                      | \_\_data.incoming\_email                                                             | from\_email, from\_name, subject, text, html, cc\_emails, date\_received, attachments |
| An SMS or WhatsApp is received        | \_\_data.incoming\_sms                                                               | sender\_number, to\_number, text, date\_received                                      |
| A message is delivered                | \_\_data.delivered\_sms                                                              | text, date\_delivered                                                                 |
| A task is created                     | \_\_data.last\_task                                                                  | task, due\_date, category, owner, created\_by                                         |
| A task is updated                     | \_\_data.updated\_task                                                               | (same shape as a new task)                                                            |
| A note is added                       | \_\_data.last\_note                                                                  | note, note\_text, category, author                                                    |
| A mention in a note                   | \_\_data.mention                                                                     | note, note\_text, author, mentioned\_user                                             |
| A comment is added                    | \_\_data.last\_comment                                                               | note, comment, comment\_text, author                                                  |
| A page is visited or link hit         | \_\_data.page\_visit                                                                 | url, utm\_\*, external\_referer, date\_hit, ip                                        |
| A web request hits a dynamic endpoint | \_\_data.<body\_field> for each body field, plus \_\_data.\_\_headers.\* for headers | see [Dynamic Endpoints, Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data)  |

### 2\. The "Store a value" action

The most direct way to put something on the notepad yourself. You give it a **name** and a **value** (computed with Flexie Scripting), and from then on it is available as `{{ __data.<name> }}`. Use it to compute something once and reuse it across many later steps.

### 3\. Steps that create records

When a step **creates a record**, the new record's id is placed in `__data.__entity_inserted_id` (and its type in `__data.__entity_type`). This is how a later step references the exact record an earlier step just created, for example, record a payment against the invoice this run just generated.

### 4\. The Webhook action

A **Webhook** action stores the other system's reply under the name you choose (default `webhook`), so a later step can branch on the response or use values from it: `{{ __data.webhook }}`, and the status code as a convenient companion value.

### 5\. The AI step

An **AI step** stores the model's output (default name `__ai_response`) so later steps can use what the AI produced, for example, send the AI-drafted reply, or branch on the AI's verdict.

## Reading values

Reach into the data with dots, exactly like record fields:

```
Hi {{ __data.incoming_email.from_name | default("there") }},

We received your message:
"{{ __data.incoming_email.subject }}"

```

Combine it with the [Flexie Scripting toolkit](https://flexie.io/resources/flexie-scripting/function-reference) to reshape or guard it:

```
{# A received payload may be JSON text, decode then read it #}
{% set order = __data.webhook | json_decode %}
Order {{ order.id }} total: {{ jsonPath(order, "$.totals.grand") | number_format(2) }}

```

Always guard values that might be absent with `default(...)` or an `{% if %}`. A signal field can be empty, and a webhook might not return what you expect.

## A worked example

> **Trigger (listener):** an email arrives in the support mailbox. **Decision (virtual condition):** does `{{ __data.incoming_email.subject }}` contain "invoice"? **Yes:** **Create a case**, subject = `{{ __data.incoming_email.subject }}`, description = `{{ __data.incoming_email.text }}`. Then **Store a value** `case_ref` \= the new case id (`{{ __data.__entity_inserted_id }}`). Then **Send an email** acknowledging case `{{ __data.case_ref }}`.

Each step uses what the ones above it produced, that is `__data` doing its job.

## Sharing across workflows (briefly)

`__data` is private to one run. If you genuinely need a value to outlive a run and be read elsewhere, the **Set shared memory** action writes to a short-lived shared store that other workflows (and templates) can read with `memoryGet("key")`. Use it sparingly, it is for cross-workflow signals, not general data passing.

## Next steps

* [Runtime, parallel execution & the tree](https://flexie.io/resources/workflows/runtime-parallel-and-tree): why data only flows downward.
* [Dynamic Endpoints, Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data): how an incoming web request lands in `__data`.

---

## Runtime, Parallel Execution & the Tree

Source: https://flexie.io/resources/workflows/runtime-parallel-and-tree

# Runtime, Parallel Execution & the Tree

Last updated 23 May 2026

![A workflow tree with multiple branches running in parallel on a worker pool](https://flexie.io/image/resources/workflows-runtime-parallel-and-tree.png)

This is the most technical page in the workflow section. You do not need it to build a simple workflow, but you do need it to build a fast, correct, busy one.

## The tree

A workflow is a **tree of steps**. Every step (except the trigger at the root) has exactly one **parent**, and execution flows from a parent down to its children.

Two connection rules:

* **Children of an action** simply run after it.
* **Children of a decision** are tagged **Yes** or **No**. The engine only follows the branch that matches the decision's result. A child tagged to neither branch is never reached. This is the most common "why did my step not run?" cause: it was left off the branch.

The tree also has guard rails: **no loops** (a step cannot lead back to itself), and the builder will **auto-attach a dangling step** to the previous one rather than leave it orphaned.

### Multiple steps under one parent

You can connect **several steps directly under the same parent**. They are siblings. The engine does not run them strictly one-after-another and wait. It dispatches them together, and they can run **in parallel**, see below.

### Multiple roots

A workflow can have **more than one starting step**. When the source fires, all roots start **in parallel**.

## How a run flows

When a workflow's source fires, the engine:

1. **Builds the batch** of records that matched the trigger.
2. **Walks the tree from the top.** For each step it works out the **timing** (run now, wait a short moment, or schedule for later), runs the step, and records one log entry for it.
3. **Routes by result.** An action's success or failure and a decision's Yes or No determine which children come next. For a decision, the batch of records is split into the ones that went **Yes** and the ones that went **No**, and each branch continues with its own set.
4. **Repeats** down each branch until every path ends.

Every step writes a log row, so you can see exactly what happened, see [the activity logs](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## Async vs Sync (background vs immediate)

A workflow has a **run mode**, chosen when you create it. The two settings in the builder are labelled **Async** and **Sync**:

|                  | **Async** (the default, runs in the background)                | **Sync** (runs immediately, inline)                                                                   |
| ---------------- | -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| How steps run    | Each step is handed to the **queue** and picked up by a worker | Each step runs **inline, right away**, in sequence                                                    |
| Speed felt       | Near real-time, but depends on how busy the queue is           | Real-time, no queue wait                                                                              |
| Best for         | Almost all CRM automations, it scales and absorbs spikes       | Cases that must complete instantly within a single interaction (an on-screen action), and short tests |
| If a step errors | It is logged and the run moves on                              | The error surfaces immediately to whatever started the run                                            |

**Use Async unless you have a specific reason not to.** It is the default because it spreads work across multiple workers, survives spikes, and keeps the rest of the system responsive. Sync mode is for the narrow set of cases that need a result **within** a live interaction.

> Some specific step types always run immediately regardless of the workflow's mode, for example an on-screen notification, where "later" has no meaning.

## How branches run in parallel

This is the part people most often misunderstand, so it is worth being precise.

In **Async** mode, when the engine reaches a point with **several steps to do next** (sibling steps under one parent, multiple starting roots, or the two branches of a decision that both have records flowing into them), it hands each of them to the queue as a **separate job**. The pool of workers then picks those jobs up and runs them **concurrently**.

So parallelism comes from two places:

* **Across steps:** independent branches advance at the same time, on different workers.
* **Across records:** a batch of many records is processed by the worker pool together, not strictly one at a time.

**What this means for you:**

* **Do not assume sibling steps finish in a fixed order.** If step B must happen **after** step A, connect B **beneath** A, do not place them side by side and hope.
* **Make steps that might run together safe to do so.** If two branches both touch the same field, decide deliberately which should win, or sequence them.
* **A later step that needs an earlier step's output** must be a **descendant** of it in the tree, that is also how the data is passed (see [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps)).

Sync mode runs steps in sequence rather than dispatching them to workers, so there is no cross-step parallelism. Another reason it is reserved for short, ordered, must-be-instant flows.

## Step timing: now, soon, or later

Each step has a **trigger mode** that decides **when** it runs once execution reaches it:

| Trigger mode  | Behaviour                                                                    |
| ------------- | ---------------------------------------------------------------------------- |
| **Immediate** | Runs as soon as the step is reached (the default).                           |
| **Interval**  | Wait a set number of minutes, hours, or days from the parent step, then run. |
| **Date**      | Run at a specific date and time.                                             |

The engine handles these efficiently with a **10-second threshold**:

* A wait of **10 seconds or less** is held in place. The engine just pauses briefly and runs the step inline. No queue round-trip.
* A wait of **more than 10 seconds** (or a fixed date in the future) is **parked**: the step is recorded with a trigger date and picked up by the scheduler when its time comes. Nothing is held open in the meantime. The worker that reached the step is freed immediately.

That is why a workflow with thousands of records on a 7-day delay costs almost nothing while they wait: each parked record is just one log row with a future trigger date. A separate scheduler sweeps for due rows on a tight cycle and dispatches them.

### Restricted hours and skip days

A step can also be **restricted** to a time window (with a timezone) and to certain weekdays. A step that becomes due **outside** its window is **kept in the queue and fired when the window opens**, not dropped. Time windows that cross midnight (e.g. 22:00 to 06:00) are handled correctly. Configuring these is covered in [Scheduling](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## How a decision splits a batch

When several records flow into a decision together, the engine evaluates the condition for each one and **splits the batch in two**: the records that came back **Yes** and the records that came back **No**. Each branch then continues with its own set, independently:

So a single workflow run can take many records down many different paths at once. Each step's log row records **how many records** passed through it and what happened, so even a complex split is auditable from the [Logs view](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## Why a busy workflow stays healthy

* **Async mode plus a worker pool** means thousands of records can be in flight without blocking the app.
* **Scheduled steps do not "wait" by holding resources.** They are parked with a trigger date and resumed on time.
* **List- and schedule-sourced workflows are paced** by an hourly limit so a huge population is spread out rather than dumped all at once (see [throttling](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting)). Record-event and listener workflows are **not** paced. They react immediately, because they are driven by individual events rather than bulk populations.

## Next steps

* [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps): how data flows down the tree.
* [Scheduling, testing & troubleshooting](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting): delays, limits, logs, and fixing problems.

---

## Scheduling, Testing & Troubleshooting

Source: https://flexie.io/resources/workflows/scheduling-testing-troubleshooting

# Scheduling, Testing & Troubleshooting

Last updated 23 May 2026

![A workflow with restricted hours, a paused step parked for later, and an activity log showing per-step outcomes](https://flexie.io/image/resources/workflows-scheduling-testing-troubleshooting.png)

A built workflow still needs to run on time, survive testing, and tell you what happened when it does not behave. Timing controls, test runs, activity logs, version history, and the mistakes that bite people most often, all in one place.

## Delays and timing

Each step has a **timing** setting:

* **Immediate** runs as soon as the step is reached (the default).
* **After a delay** waits an interval (minutes, hours, or days) after the parent step, then runs. Use it for follow-ups: "wait 2 days, then send a check-in."
* **At a specific date and time** runs at a fixed moment.

A step that is delayed or scheduled is **parked and resumed on time**. It does not hold anything open while it waits, so you can have huge numbers of records waiting on a delay without any cost in the meantime.

## Restricted hours and skip days

Any step can be restricted to a **time window** and to **certain days**:

* Set a **from** and **to** time (and a timezone) so the step only runs during, say, 09:00 to 17:00.
* Choose **days to skip** (e.g. weekends).

A step that becomes due **outside** its allowed window is not dropped. It **waits in the queue and fires when the window opens**. Time windows that cross midnight (e.g. 22:00 to 06:00) are handled correctly.

This is how you keep customer-facing messages polite, no 3am SMS, without complicating the rest of the workflow.

## Throttling (the hourly limit)

Each workflow has an **hourly limit** (default 3,000) on how many records flow through it for **list-** and \*\*schedule-\*\*sourced workflows. This paces bulk processing so a huge population is spread out rather than dumped at once.

### How the maths works

The scheduler sweeps for due work on a tight cycle. To pace evenly across the hour it grants each sweep **one-tenth** of the workflow's hourly limit:

| Hourly limit    | Per-sweep quota                            | Sweeps per hour |
| --------------- | ------------------------------------------ | --------------- |
| 3,000 (default) | 300 records                                | 10              |
| 1,000           | 100 records                                | 10              |
| 10,000          | 1,000 records                              | 10              |
| < 10            | the full limit, but only **once per hour** | 1               |

So a list-sourced workflow on the default limit will process about **300 records roughly every six minutes**, not 3,000 all at once at the top of the hour. If a large list-driven workflow seems "slow," it is usually this pacing doing its job. Raise the limit if you genuinely need more throughput and the channels it sends on can absorb it.

### What is and is not paced

| Source            | Paced by the hourly limit?                           |
| ----------------- | ---------------------------------------------------- |
| **Lists**         | Yes                                                  |
| **Scheduled**     | Yes                                                  |
| **Record events** | **No**, reacts to each event as it happens           |
| **Listener**      | **No**, reacts to each external signal as it arrives |
| **Manual**        | No                                                   |

Record-event and listener workflows are driven by individual events, so there is nothing to pace. They are inherently spread out over the day.

## Test a workflow before going live

**Never publish blind.** Open the workflow and use the **test run**: it executes the whole tree against **one real record** you choose, and shows you the outcome of every step. What it would send, what it would change, which branch each decision took.

Because the test walks the real steps, it is the fastest way to catch a wrong field name, an empty value, or a branch connected to the wrong side of a decision. Test, read the per-step results, fix, test again, then publish.

## The activity logs

A live workflow records what it does. From an open workflow you can see:

| View                | What it shows                                                                                      |
| ------------------- | -------------------------------------------------------------------------------------------------- |
| **Processed**       | records that have been through the workflow, and how                                               |
| **Queued**          | records waiting on a delay or schedule                                                             |
| **Logs**            | the per-step log: which step ran for which record, the result, and the failure reason if it failed |
| **Activity stream** | a live feed and summary of workflow activity                                                       |

When something is not behaving, the **Logs** view is where you look first. Every step writes a row, including a **failure reason** when it fails.

## Versions and rollback

Every time you save a workflow, Flexie keeps a **version**. From an open workflow:

* **Versions** lets you review the history of changes.
* **Roll back** restores an earlier version if a change caused a problem.

This makes editing a live workflow safe: if an edit misbehaves, roll back.

## Common pitfalls

| Symptom                                                            | Usual cause                                                                                                                                                                                                                | Fix                                                                                                                                                                       |
| ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| A step never runs                                                  | It is a child of a decision but is not attached to the **Yes** or **No** branch                                                                                                                                            | Connect it to the correct branch                                                                                                                                          |
| Steps run in the "wrong order"                                     | Two steps placed as **siblings** run in parallel, not in sequence                                                                                                                                                          | Put the second step **beneath** the first so it is a descendant                                                                                                           |
| A later step cannot see an earlier step's value                    | The later step is not a **descendant** of the step that produced the value                                                                                                                                                 | Re-parent it below the producing step (see [Passing data](https://flexie.io/resources/workflows/passing-data-between-steps))                                                               |
| Two branches both touch the same field, with inconsistent results  | They run in parallel, neither one is "first"                                                                                                                                                                               | Sequence them as parent and child, or split into separate decisions so only one branch runs                                                                               |
| An "update" trigger never fires                                    | No watched field change was configured                                                                                                                                                                                     | Specify which field change should trigger it                                                                                                                              |
| The "update" trigger fires too often                               | Too many fields watched, or watched fields that change for unrelated reasons                                                                                                                                               | Narrow the watched field list to the ones you actually care about                                                                                                         |
| A list-sourced workflow never reaches some records                 | The list excludes them, **or** the hourly limit is still working through the population                                                                                                                                    | Check the list definition and the throttle, give it time, or raise the limit                                                                                              |
| A bulk workflow is slow                                            | The hourly limit is pacing it                                                                                                                                                                                              | Raise the limit (within channel capacity), or use a record-event source if appropriate                                                                                    |
| A message went out at a bad hour                                   | No restricted hours on the send step                                                                                                                                                                                       | Add a time window or skip days to the step                                                                                                                                |
| A scheduled step seems to fire at unexpected times                 | Restricted hours or skip days have pushed it to the next allowed moment                                                                                                                                                    | Look at the step's trigger date in the **Queued** view                                                                                                                    |
| A webhook intermittently fails                                     | Transient errors with no retry                                                                                                                                                                                             | Enable retries on the Webhook action                                                                                                                                      |
| A webhook **always** fails                                         | Wrong URL, wrong method, wrong body shape, or auth missing on the other side                                                                                                                                               | Check the step's log, the response body and status code are recorded                                                                                                      |
| A value is blank in output                                         | The field was empty for that record                                                                                                                                                                                        | Guard with default(...), coalesce(...), or an {% if %}                                                                                                                    |
| A token like {{ \_\_data.X }} returns blank                        | Either nothing has been stored under that name **above** this step, or the name is misspelt                                                                                                                                | Confirm where X is written and that the writing step is an ancestor of the reading step                                                                                   |
| A condition is **always** taking the **No** branch                 | The left value is reading from the wrong place. Most commonly a body field referenced as bare {{ X }} when it should be {{ \_\_data.X }}, or a current-record field referenced as {{ entity.X }} when it should be {{ X }} | See [Dynamic Endpoints, Receiving data](https://flexie.io/resources/dynamic-endpoints/receiving-data) and [Flexie Scripting, Language basics](https://flexie.io/resources/flexie-scripting/language-basics) |
| is\_empty or is\_not\_empty rules give odd results                 | The field is actually NULL, not empty                                                                                                                                                                                      | Use is\_null or is\_not\_null                                                                                                                                             |
| A "between" date filter excludes the boundary                      | "Between" is inclusive on both ends; you may have given it dates rather than datetimes                                                                                                                                     | Use datetimes (2026-05-01 00:00:00 to 2026-05-02 23:59:59) for full-day inclusion                                                                                         |
| Records show up in **Queued** but never run                        | They are outside the step's restricted window or skip days                                                                                                                                                                 | Adjust the window, or wait for it to open                                                                                                                                 |
| The workflow is published but nothing happens                      | The workflow is outside its publish window                                                                                                                                                                                 | Check the publish window dates                                                                                                                                            |
| A test run looked good but the live workflow misbehaves            | Test runs against one chosen record; live data has variations the test did not cover                                                                                                                                       | Test against several different records, including edge cases (empty fields, very large values, missing relations)                                                         |
| A run created duplicate records                                    | An action with retry, or two branches that both create                                                                                                                                                                     | Make creation conditional, or de-duplicate before creating with findOne                                                                                                   |
| Output changed unexpectedly after editing the workflow             | A new version is live; the old behaviour is in a previous version                                                                                                                                                          | Use **Versions** to compare and **Roll back** if needed                                                                                                                   |
| AI-built workflows have decisions with the same condition repeated | The AI prefers explicit conditions per branch                                                                                                                                                                              | Combine into one decision with AND or OR if simpler                                                                                                                       |

## A pre-publish checklist

1. Right **record type** and **source** for the real trigger?
2. For update triggers, the **watched field changes** are set?
3. Every decision's **Yes and No branches** connected correctly?
4. Steps that depend on earlier output are **descendants** of those steps?
5. Customer-facing sends have **time windows** where appropriate?
6. **Tested** against a real record and the per-step results look right?
7. **Publish window** set if it should only be active for a period?

## Next steps

* [Overview](https://flexie.io/resources/workflows/overview): the section map.
* [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview): workflows triggered by incoming web requests.

---

## Triggers & Sources

Source: https://flexie.io/resources/workflows/triggers-and-sources

# Triggers & Sources

Last updated 23 May 2026

![The five workflow sources, record events, lists, scheduled, listener, and manual](https://flexie.io/image/resources/workflows-triggers-and-sources.png)

A workflow's source decides **when** it runs and **which records** flow into it. You set it when building the workflow.

## The five sources at a glance

| Source            | Starts when…                   | Typical use                                                                                                 | Throttled?               |
| ----------------- | ------------------------------ | ----------------------------------------------------------------------------------------------------------- | ------------------------ |
| **Record events** | a record is created or updated | "When a deal is won," "When a lead is created"                                                              | No, fires on the event   |
| **Lists**         | a record matches a saved list  | recurring processing of everything matching a segment                                                       | Yes, by the hourly limit |
| **Scheduled**     | a set cycle elapses            | "every Monday," "every 6 hours"                                                                             | Yes, by the hourly limit |
| **Listener**      | an external signal arrives     | an email, SMS, or WhatsApp comes in, a form is submitted, a page is visited, a web request hits an endpoint | No, fires on the signal  |
| **Manual**        | you press Run                  | one-off or on-demand processing                                                                             | No                       |

## 1\. Record events

The workflow fires the moment a record of its type is **created** or **updated**.

* **On create** runs for every new record of that type.
* **On update** lets you specify **which field changes** matter. The workflow then fires only when one of those fields changes (for example, only when a deal's **stage** changes, not on every edit). Configuring the watched field changes is required for update triggers, without it the trigger has nothing to react to.

### Configuring "on update": watched field changes

For each watched field you can specify:

* **The field**: any standard or custom field on the record type.
* **The "from" value** (optional): only fire if the field was previously this value. Leave blank to fire for any previous value.
* **The "to" value** (optional): only fire if the field is now this value. Leave blank to fire for any new value.

You can list as many field changes as you need; the trigger fires when **any** of them match. This is how you build precise triggers:

* **Watch:** deal field `stage` → from `*` to `Won` → fires only when a deal becomes Won, regardless of which stage it came from.
* **Watch:** invoice field `status` → from `pending` to `paid` → fires only on the pending-to-paid transition.

### Both create and update

You can configure a workflow to fire on **create** **and** on **update** at the same time, handy when the same response is needed whether a record just arrived or just reached the relevant state.

### Speed and throttling

Record-event workflows react in real time and are **not** subject to the hourly throttle. The change is detected and the workflow's first step is dispatched immediately.

> Example: record type **Deal**, source **Record events**, on update when **stage** changes to **Won**, then onboarding steps run.

## 2\. Lists

The workflow processes **every record that matches a saved list** (a smart list or segment). It is the right choice when you want to act on a **population** of records on an ongoing basis, rather than reacting to a single change.

Saved lists are managed per record type. Build the list first, then point the workflow at it.

Because a list can be large, list-sourced workflows are paced by the **hourly limit** so they do not flood the system, see [throttling](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting).

## 3\. Scheduled

The workflow runs on a **repeating cycle** you define: every **N** minutes, hours, or days. Use it for time-driven work that is not tied to a single record change: weekly digests, nightly housekeeping, renewal sweeps.

### Configuring the frequency

The frequency is a **number** and a **unit**, for example `6` × `hour` means "every 6 hours." The supported units are minutes, hours, and days. From those two controls you can build everything from "every 5 minutes" to "every 7 days."

### What the workflow runs on

A scheduled workflow still has a **record type**. When it fires, it processes records of that type, often a saved list attached to it. For workflows that do not operate on a stored record (a daily digest, a periodic sync, a cleanup), choose the **virtual** record type, see [Virtual entities](https://flexie.io/resources/dynamic-endpoints/virtual-entities).

### Speed and throttling

Scheduled workflows are paced by the **hourly limit** so a high-frequency schedule on a large population does not overwhelm the system, and they respect any [restricted hours and skip days](https://flexie.io/resources/workflows/scheduling-testing-troubleshooting) you set.

## 4\. Listener

The workflow waits for an **external signal** and fires when it arrives. The signal is the first step (the listener) and its children run when the signal comes in. Available signals include:

* **An email arrives** in a connected mailbox
* **An SMS or WhatsApp message is received**
* **A message is delivered**
* **A form is submitted** (see [Forms](https://flexie.io/resources/forms/overview))
* **A page is visited or a tracked link is hit**
* **A task or note is created, or a comment or mention is added**
* **A web request hits a dynamic endpoint**, see [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview)

Some listeners can only sit **inside** a workflow (for example "email opened" or "link clicked" only make sense after an email has been sent by an earlier step). Others act as the **starting point** of the whole workflow. The builder only offers each listener where it is valid.

Listener-sourced workflows fire on the signal and are **not** throttled.

> When a listener fires, the data the signal carried (the email's subject and body, the SMS text, the form fields, the request payload) is made available to the following steps as `{{ __data.… }}`. See [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps).

## 5\. Manual

The workflow runs only when **you press Run**, from the workflow itself, or by pushing records into it from a list view. Use it for one-off jobs, for testing a process on demand, or for steps a person should consciously kick off.

A workflow can be configured to allow or disallow manual running.

## Choosing the right source

Ask: **what is the real trigger?**

* "Something changed on one record" → **Record events**.
* "Everything that currently matches a condition" → **Lists**.
* "On a clock or calendar" → **Scheduled**.
* "Something arrived from outside" (message, form, web request) → **Listener**.
* "Only when a person decides" → **Manual**.

Mixing concerns is the usual mistake, for example using a scheduled sweep to catch a change that record-events would catch instantly. Prefer the source that matches the real trigger; it is faster and lighter.

## A note on record types and "virtual" workflows

Most workflows run on a real record type (Lead, Deal, Invoice, a custom record). There is also a special **virtual** record type used when a workflow is driven by an incoming web request rather than a stored record. That is the [Dynamic Endpoints](https://flexie.io/resources/dynamic-endpoints/overview) topic. Virtual workflows can only use the **Listener** or **Scheduled** sources.

## Next steps

* [Actions & decisions](https://flexie.io/resources/workflows/actions-and-decisions): what the workflow does once it starts.
* [Passing data between steps](https://flexie.io/resources/workflows/passing-data-between-steps): using what the trigger provided.

---

## Security & Infrastructure

Source: https://flexie.io/security-infrastructure

Legal

# Security and Infrastructure Overview

Effective date: 10 May 2026

## 1\. Purpose

This page explains, in plain terms, how Flexie protects your data and runs its infrastructure. It is informational and does not replace the Terms, Privacy Policy, Data Retention Policy, or Data Processing Agreement.

## 2\. Where your data is hosted

Flexie runs on European infrastructure. Core hosting, compute, storage, and backups of Customer Data are kept in EU/EEA data centers, provided by:

* **OVH SAS**, 2 Rue Kellermann, 59100 Roubaix, France.
* **Hetzner Online GmbH**, Industriestr. 25, 91710 Gunzenhausen, Germany.
* **Amazon Web Services EMEA SARL**, 38 avenue John F. Kennedy, L-1855 Luxembourg.

These are Flexie's only infrastructure sub-processors. Services that a customer connects through integrations (for example, their own telephony, email, or AI provider) are the customer's vendors, not Flexie's sub-processors.

## 3\. Encryption

* **In transit:** HTTPS/TLS is enforced for all web and API access. Flexie does not accept non-encrypted connections.
* **At rest:** stored data is encrypted.

## 4\. Access and authentication

* Two-factor authentication (2FA) is available for user accounts.
* Role-based access control with least-privilege access, so people and systems can reach only what they need.
* Logical separation between tenants, keeping each customer's data isolated from others.

## 5\. Monitoring, backups, and resilience

* Security logging and monitoring to detect and investigate suspicious activity.
* Regular backups with recovery procedures, so data can be restored after a failure.

## 6\. Operational security

* Timely patching and server hardening.
* Documented internal security procedures that are strictly applied and maintained on an ongoing basis.
* A defined incident response process for security incidents and personal data breaches.

## 7\. AI and integration data controls

Flexie does not operate AI models or communication channels itself. Calls, email, messaging, and AI run through services the customer connects and controls. Where data is sent to those services, it is sent on the customer's instruction and configuration.

Flexie provides field-level permission and exclusion controls so customers can keep selected fields, such as phone numbers, email addresses, identifiers, or sensitive notes, out of AI-related workflows or external payloads. Customers choose what is sent and which fields are excluded.

## 8\. Shared responsibility

Security is a partnership. Flexie secures the platform and the infrastructure it runs on. Customers are responsible for their own users and roles, account credentials, two-factor enrolment, workflow logic, integration endpoints and credentials, AI vendor selection, field-exclusion settings, and using the Service in line with applicable law.

---

## Terms of Service

Source: https://flexie.io/terms

Legal

# Terms of Service

Effective date: 10 May 2026

## 1\. Scope

These Terms are entered into with Flexie CRM e.U., operated by Eriol Gjergji, Fritz-Konzert-Strasse 7, Top 1/3, 6020 Innsbruck, Austria, UID/VAT: ATU81616707, Firmenbuchnummer: FN 679939 k, Firmenbuchgericht: Landesgericht Innsbruck ("Flexie").

These Terms govern access to and use of Flexie CRM, including the CRM platform, workflow automation, reporting, APIs, integration tooling, support services, documentation, and related services (the "Service"). By creating an account, subscribing to the Service, signing an order form, or using the Service, Customer accepts these Terms.

## 2\. Eligibility (B2B Only) and Know Your Customer

The Service, and all other services offered under the Flexie brand, are offered exclusively to businesses (B2B). To access, purchase, or use any Flexie service, Customer must be a registered legal entity, a registered sole proprietorship, or another lawfully registered business (Unternehmer within the meaning of § 1 UGB) acting in the course of its trade, business, or profession. Flexie does not sell to, and the Service is not offered to, consumers, private individuals acting outside a business capacity, or unregistered entities. By accepting these Terms, Customer represents and warrants that it qualifies as a business under this Section.

Flexie applies Know Your Customer (KYC) checks before activating, renewing, or expanding access to the Service. Customer shall provide accurate identification, registration, beneficial ownership, authorized representative, billing, tax, and address information, and shall supply supporting documents on request, such as commercial register extract, VAT registration, identification of authorized signatories, or equivalent. Flexie may verify this information against public registers, sanctions and anti-money-laundering / counter-terrorism financing lists, payment provider checks, and other lawful sources, and may repeat these checks periodically.

Flexie may refuse onboarding, refuse a transaction, suspend access, or terminate the agreement if KYC checks cannot be completed, if the information provided is incorrect, incomplete, or outdated, if Customer no longer qualifies as a business, if Customer or its beneficial owners appear on applicable sanctions or restricted-party lists, or if continuing the relationship would breach applicable law, including AML/CTF, sanctions, export control, or tax regulations. Customer shall notify Flexie without undue delay of material changes to information previously provided.

## 3\. Service Description

Flexie CRM is a CRM and workflow automation platform. The Service provides tools for managing records, entities, users, roles, permissions, dashboards, workflows, APIs, imports, exports, and customer-configured integrations. The exact functionality depends on the subscribed plan, configuration, and enabled features.

## 4\. Accounts and Users

Customer is responsible for maintaining account credentials, managing user access, assigning appropriate roles and permissions, and ensuring that its users comply with these Terms. Customer is responsible for activity performed through its account unless caused by Flexie's breach of these Terms or applicable law.

## 5\. Customer Data

Customer retains all rights in data submitted to, stored in, generated through, or processed by the Service ("Customer Data"). Flexie does not own Customer Data. Flexie processes Customer Data only as necessary to provide, secure, maintain, support, and improve the Service, and as otherwise permitted by the applicable agreement.

Customer is responsible for the accuracy, quality, lawfulness, and permitted use of Customer Data, including ensuring that Customer has the necessary legal basis, notices, consents, permissions, and rights to submit and process such data through the Service.

## 6\. Data Processing Agreement

Where Customer uses Flexie CRM to process Personal Data for which Customer acts as controller, the Flexie Data Processing Agreement forms part of these Terms and governs Flexie's processing of Customer Personal Data as processor.

The [Data Processing Agreement (PDF)](https://flexie.io/documents/flexie-dpa-de-en-ai-act.pdf) is available to download. The current DPA is version 2.0, effective 19 May 2026\. By creating an account, subscribing to the Service, signing an order form, accepting these Terms, or continuing to use the Service, Customer accepts the DPA.

In case of conflict, the DPA prevails only for the subject matter of processing Customer Personal Data under applicable data protection law.

## 7\. Customer-Configured Integrations

The Service provides tools that allow Customer to configure workflows, API calls, webhooks, email delivery, SMS delivery, telephony actions, database connections, AI/API calls, and other integrations with third-party or customer-owned systems.

Such integrations are selected, configured, authorized, and controlled by Customer. Flexie does not select, contract, appoint, or manage those third-party systems on Customer's behalf unless expressly agreed in writing. Customer is responsible for the third-party service, credentials, endpoint, payload content, legal basis, notices, consents, data processing terms, international transfer compliance, and any sector-specific obligations related to such integrations.

## 8\. AI and Automation

Flexie provides CRM, workflow, automation, permission, and integration tooling. Flexie does not train, fine-tune, own, operate, or run general-purpose AI models or third-party AI models for Customer's use of the Service unless expressly agreed in writing.

Customer may connect external AI vendors, models, APIs, or endpoints through customer-configured integrations. Customer is responsible for selecting and configuring those services, determining the purpose and legal basis, validating outputs, applying human oversight where required, configuring field exclusions, and complying with applicable law, including the GDPR and Regulation (EU) 2024/1689 (EU AI Act).

**Roles under the EU AI Act.** Within the meaning of Regulation (EU) 2024/1689 (EU AI Act), Flexie is not a provider of an AI system, not a deployer of an AI system, and not a provider of a general-purpose AI model, in respect of Customer's use of the Service. Flexie offers software that allows Customer to configure connections to AI systems and models that Customer selects. Where Customer configures such an AI integration, Customer is the deployer of that AI system within the meaning of Article 3(4) of the EU AI Act and bears the obligations applicable to deployers under Articles 4 and 26 of the EU AI Act and any other obligations imposed on deployers by that Regulation.

**Prohibited AI practices.** Customer shall not use the Service to engage in any AI practice prohibited under Article 5 of the EU AI Act, including:

1. subliminal, manipulative, or deceptive techniques that materially distort behavior and cause significant harm;
2. exploitation of vulnerabilities of persons due to age, disability, or socio-economic situation that causes significant harm;
3. social scoring of natural persons by public or private actors leading to detrimental or unfavourable treatment;
4. risk assessment of natural persons to predict criminal behaviour based solely on profiling or personality traits;
5. untargeted scraping of facial images from the internet or CCTV footage to build or expand facial-recognition databases;
6. emotion recognition in workplaces or educational institutions, except for safety or medical purposes;
7. biometric categorization to deduce special categories of personal data;
8. real-time remote biometric identification in publicly accessible spaces for law enforcement purposes, outside the narrow exceptions permitted by the EU AI Act.

**High-risk AI use cases.** If Customer uses the Service in a way that constitutes a high-risk AI system under Article 6 or Annex III of the EU AI Act, including in the areas of biometrics, critical infrastructure, education and vocational training, employment and worker management, access to essential public and private services, law enforcement, migration, asylum and border control, or administration of justice and democratic processes, Customer is responsible for ensuring full compliance with all applicable EU AI Act obligations. These include risk management, data and data governance, technical documentation, record-keeping, transparency, human oversight, accuracy, robustness, and cybersecurity. Flexie's software tooling is not a substitute for the conformity assessment or the obligations that the EU AI Act places on Customer as deployer.

**Transparency obligations.** Where Customer uses the Service to interact with natural persons by means of an AI system, such as a chatbot, voice agent, emotion recognition feature, biometric categorization feature, or to generate or manipulate image, audio, or text content (including synthetic or deepfake content), Customer is responsible for satisfying the transparency obligations of Article 50 of the EU AI Act. These include informing natural persons that they are interacting with an AI system, disclosing AI-generated or AI-manipulated content where required, and labelling deepfake content. Flexie does not perform these disclosures on Customer's behalf.

**AI literacy.** Each party shall take measures to ensure, to its best extent, a sufficient level of AI literacy of its staff and other persons dealing with the operation and use of AI systems on its behalf, as required by Article 4 of the EU AI Act, taking into account the technical knowledge, experience, education, and training of those persons and the context in which the AI systems are used.

## 9\. Acceptable Use

Customer shall not use the Service to violate applicable law, infringe rights, send unlawful or unsolicited communications, introduce malware, attempt unauthorized access, interfere with the Service, reverse engineer the Service except where permitted by law, or process data in a way that Customer is not legally entitled to process.

## 10\. Security

Flexie implements reasonable technical and organizational measures designed to protect the Service and Customer Data. Customer remains responsible for configuring user permissions, authentication practices, integration credentials, workflow logic, and field-level controls within its account.

## 11\. Support, Maintenance, and Changes

Flexie may update, improve, modify, or discontinue parts of the Service from time to time. Flexie will use reasonable efforts to avoid materially reducing core functionality without notice where practicable. Support is provided according to the applicable plan, order form, or written arrangement.

## 12\. Fees, Billing, and Taxes

Flexie's main business model is a recurring subscription fee for the Service, billed in advance for the applicable subscription period. Flexie may additionally charge for implementation, configuration, migration, custom workflow, integration, training, or other professional services, scoped, evaluated, and quoted on a per-customer basis according to the requested scenario or project. Fees, payment terms, invoicing, renewal, and cancellation rules are set out in the applicable order form, subscription plan, invoice, or written agreement.

All prices, quotes, and listed fees are exclusive of VAT and any other applicable taxes, duties, levies, or withholdings, which are added at the rate required by law and shown on the invoice.

Payments are processed through Flexie's authorized payment channels: PayPro Global, Stripe, and direct bank account transactions backed by a signed written agreement. Other payment methods may be accepted only where expressly agreed in writing. Customer is responsible for ensuring timely payment through the applicable channel.

Flexie aims to keep pricing stable and will use reasonable efforts to avoid price increases. However, fees may be adjusted where required for reasons outside Flexie's reasonable control, including changes in infrastructure or sub-processor costs, third-party service costs, currency effects, taxes, regulatory or legal changes, or material changes in the scope of the Service. Material price changes affecting Customer's subscription will be communicated by reasonable means in advance and will take effect in accordance with the applicable order form, plan, or written agreement.

Refunds are governed by the Refund Policy in Section 13 and by any rights that cannot be excluded under applicable law.

## 13\. Refund Policy

Flexie offers a 30-day money-back guarantee, no questions asked. If Customer is not satisfied with the Service for any reason, Customer may request a full refund of fees paid for the initial subscription within 30 days of the original purchase date by contacting [support@flexie.io](mailto:support@flexie.io). Refunds will be issued to the original payment method within a reasonable period after the request.

The 30-day money-back guarantee applies once per Customer and covers the initial subscription purchase. It does not apply to subsequent renewals, add-on purchases made after the initial 30-day window, one-time implementation or professional services already delivered, or third-party charges incurred through customer-configured integrations (for example external AI providers, telephony, SMS, or email delivery vendors selected by Customer).

After the 30-day window, fees are non-refundable except where required by law or expressly stated in the applicable agreement. Nothing in this Section limits mandatory consumer withdrawal rights where they apply.

## 14\. Suspension and Termination

Flexie may suspend access to the Service where reasonably necessary due to non-payment, security risk, unlawful use, breach of these Terms, or use that may harm the Service or other customers. Either party may terminate according to the applicable order form or subscription terms.

## 15\. Data Export and Deletion

During the subscription term, Customer may export or delete Customer Data using available Service functionality, subject to technical capabilities and applicable retention rules. After termination, Customer Data may be made available for export for a reasonable period and then deleted or made inaccessible, subject to backup rotation and legal retention requirements.

## 16\. Intellectual Property

Flexie and its licensors retain all rights in the Service, software, documentation, designs, workflows, templates, technology, and related intellectual property. Customer receives a limited, non-exclusive, non-transferable right to use the Service during the subscription term in accordance with these Terms.

## 17\. Confidentiality

Each party shall protect confidential information received from the other party using reasonable care and shall use it only for purposes related to the Service, unless disclosure is required by law.

## 18\. Warranty Disclaimer

The Service is provided on a commercially reasonable basis. To the maximum extent permitted by Austrian law, and without prejudice to statutory warranty rights under §§ 922 ff. ABGB, Flexie does not warrant that the Service will be uninterrupted, error-free, secure against every attack, free from delays, free from data loss, or suitable for every Customer use case, business goal, or technical environment. Flexie disclaims all implied warranties to the extent permitted by law, including warranties of merchantability, fitness for a particular purpose, accuracy of results, and non-infringement.

Customer is responsible for testing workflows, integrations, AI settings, automations, prompts, payloads, and outputs before relying on them in production, and for monitoring their continued correctness over time. Where Customer qualifies as a business under Section 2 and § 377 UGB applies, Customer shall inspect the Service or delivered work without undue delay and shall give written notice of any apparent defects without undue delay; failure to give timely notice results in loss of warranty rights to the extent provided by § 377 UGB.

Nothing in this Section limits or excludes rights or liability that cannot be limited or excluded under mandatory Austrian or EU law, including liability for personal injury or death, intent (Vorsatz), gross negligence (grobe Fahrlässigkeit) of Flexie's executive bodies, fraudulent misrepresentation, or claims under the Austrian Product Liability Act (Produkthaftungsgesetz, PHG).

## 19\. Limitation of Liability

Each party is responsible for its own breach of these Terms and applicable law. Subject to the carve-outs set out in this Section, and to the maximum extent permitted by Austrian law, Flexie's aggregate liability to Customer arising out of or in connection with the Service and these Terms is limited to the amounts actually paid by Customer to Flexie for the Service during the twelve (12) months preceding the event giving rise to liability.

To the maximum extent permitted by law, Flexie shall not be liable for indirect, consequential, incidental, or special damages, loss of profit, loss of revenue, loss of opportunity, loss of goodwill, loss of anticipated savings, loss or corruption of data, or business interruption, regardless of the legal theory of the claim.

Flexie is not responsible for customer-selected vendors, customer-configured integrations, external AI services selected by Customer, Customer's legal basis, Customer's communications, Customer's recipient lists, Customer's workflow logic, or Customer's compliance decisions.

The limitations and exclusions in this Section do not apply to, and nothing in these Terms limits or excludes, liability for:

1. personal injury or death caused by Flexie's negligent act or omission;
2. intent (Vorsatz);
3. gross negligence (grobe Fahrlässigkeit) of Flexie's executive bodies;
4. liability under the Austrian Product Liability Act (Produkthaftungsgesetz, PHG);
5. fraudulent misrepresentation; or
6. any other liability that cannot be limited or excluded under mandatory Austrian or EU law.

Claims must be brought within the limitation periods prescribed by applicable law. Customer's notification duty under § 377 UGB, where applicable, is preserved.

## 20\. Indemnification

Customer shall indemnify, defend, and hold Flexie and its affiliates, directors, employees, and agents harmless from and against any third-party claims, demands, actions, damages, losses, liabilities, fines, penalties, and reasonable legal costs arising out of or in connection with:

1. Customer Data;
2. Customer-configured integrations, AI endpoints, or third-party services selected and controlled by Customer;
3. Customer's communications, recipient lists, and outreach conducted through the Service;
4. Customer's breach of these Terms or applicable law;
5. Customer's use of the Service in a manner not permitted under these Terms or the applicable agreement; or
6. infringement of third-party rights by Customer Data, content uploaded by Customer, or configurations created by Customer.

Flexie shall indemnify Customer against third-party claims that Customer's authorized use of the Service, as provided by Flexie and used in accordance with these Terms, directly infringes a valid Austrian or EU intellectual property right, subject to Customer:

1. notifying Flexie of the claim without undue delay;
2. giving Flexie sole control of the defence and settlement; and
3. providing reasonable cooperation at Flexie's expense.

This indemnity does not apply to claims arising from Customer Data, Customer-configured integrations, modifications not made by Flexie, combinations of the Service with non-Flexie products or services, or use of the Service contrary to these Terms or applicable law. Flexie's indemnification obligation under this paragraph is subject to the limitations of liability in Section 19, except where Austrian or EU mandatory law does not permit such limitation.

The indemnified party shall notify the indemnifying party in writing of the claim without undue delay, give the indemnifying party reasonable control of the defence, and provide reasonable cooperation. Settlements that impose non-monetary obligations on the indemnified party require its prior written consent.

## 21\. Business Customers Only

The Service is offered to business customers only, as set out in Section 2\. The Service is not intended for, marketed to, or sold to consumers, and Flexie does not enter into agreements with consumers. If, despite this restriction, a person is legally treated as a consumer in a specific case, nothing in these Terms excludes rights that cannot be excluded by law in that case.

## 22\. Changes to Terms

Flexie may update these Terms from time to time. Material changes will be communicated to Customer in advance of the effective date by reasonable means, such as email to the address on file, account notice, or in-product notice. Non-material changes, including clarifications, typographical corrections, and changes required by law, take effect on publication. Continued use of the Service after the effective date of updated Terms constitutes acceptance, unless mandatory law requires a different process. If Customer does not accept a material change, Customer may terminate the affected subscription by written notice before the effective date, in which case Flexie shall refund the pro-rated portion of prepaid fees for the unused subscription term.

## 23\. Service Levels

These Terms do not include a fixed service-level agreement (SLA). Service availability targets, response times, support hours, escalation procedures, scheduled maintenance windows, and any remedies for missed targets are agreed individually with each Customer in the applicable order form, plan, or written agreement, and are tailored to and aligned with the pricing and scope of the subscription selected by Customer. In the absence of an agreed SLA, the Service is provided on a commercially reasonable basis as set out in Section 18.

## 24\. Publicity and Customer References

Flexie may use anonymized customer implementations, configurations, workflows, and use cases to illustrate features, capabilities, or example deployments of the Service, including in documentation, marketing materials, demonstrations, sales conversations, and case studies. When doing so, Flexie shall not disclose Customer's name, brand, logo, trademarks, or Customer Personal Data, and shall not expose Customer Data in identifiable form. Customer Data used for such purposes shall be anonymized, pseudonymized, or replaced with synthetic data to the extent necessary to prevent identification of Customer or any data subject.

Public references to Customer as a customer of Flexie, including use of Customer's name or logo on the Flexie website or in marketing collateral, require Customer's prior written consent.

## 25\. Feedback

Customer may submit suggestions, ideas, feature requests, comments, or other feedback about the Service ("Feedback"). Feedback is provided voluntarily and on a non-confidential basis. Flexie may use, modify, and incorporate Feedback into the Service and related products without restriction, attribution, or compensation. Customer shall not submit Feedback that contains Customer Personal Data, third-party confidential information, or third-party intellectual property that Customer is not entitled to disclose.

## 26\. Subcontractors

Flexie may engage subcontractors to support the provision and operation of the Service, including for hosting, infrastructure, payment processing, billing, support, security, and similar operational functions. Subcontractors that process Customer Personal Data on Flexie's behalf are governed by the Data Processing Agreement referenced in Section 6, which sets out the sub-processor regime, authorization process, and notice mechanism for personal data. Engagement of subcontractors that do not process Customer Personal Data is at Flexie's discretion. Flexie remains responsible for the performance of its subcontractors under these Terms.

## 27\. Sanctions, Export Control, and Anti-Corruption

Each party shall comply with applicable economic and trade sanctions, export control laws, and anti-money-laundering / counter-terrorism financing regulations, including those of the European Union, Austria, the United Nations, and, where applicable, the United Kingdom and the United States. Customer represents and warrants that Customer, its beneficial owners, and its authorized users are not subject to applicable sanctions or restricted-party lists and that Customer will not use the Service in a manner that would cause Flexie to violate these laws.

Each party shall comply with applicable anti-corruption and anti-bribery laws, including the Austrian Corruption Criminal Code (Korruptionsstrafrechtsänderungsgesetz) and equivalent rules in other jurisdictions where the party operates. Neither party shall offer, give, or accept any improper benefit, payment, or advantage in connection with these Terms or the Service.

If Flexie reasonably believes that continued provision of the Service would breach this Section, Flexie may suspend or terminate the agreement in accordance with Sections 2 and 14 without liability.

## 28\. Force Majeure

Neither party is liable for failure or delay in performance caused by events outside its reasonable control, including acts of war, armed conflict, terrorism, civil unrest, strikes, labor disputes, natural disasters, fires, floods, pandemics, epidemics, energy or telecommunications outages, internet or cloud-provider disruptions, denial-of-service or other cyberattacks beyond reasonable defensive measures, sanctions, embargoes, government or regulator orders, and acts or omissions of authorities ("Force Majeure"). The affected party shall notify the other party without undue delay and use reasonable efforts to mitigate the impact.

Force Majeure does not relieve Customer of payment obligations for the Service already provided. If a Force Majeure event continues for more than sixty (60) consecutive days, either party may terminate the affected subscription on written notice, without liability for the event itself.

## 29\. Assignment

Customer shall not assign, transfer, sublicense, or otherwise dispose of these Terms, the Service, the account, or any rights or obligations under these Terms, in whole or in part, without Flexie's prior written consent. Any purported assignment in breach of this Section is void.

Flexie may assign or transfer these Terms in whole or in part, including in connection with a merger, acquisition, corporate reorganization, change of control, or sale of all or substantially all of its assets or the business relating to the Service. Flexie shall provide reasonable notice to Customer of such assignment.

## 30\. Severability

If any provision of these Terms is held to be invalid, unenforceable, or void by a court or competent authority of relevant jurisdiction, the remaining provisions remain in full force and effect. The invalid or unenforceable provision shall be replaced by a valid and enforceable provision that most closely reflects the original economic and legal intent of the parties. The parties acknowledge this is a salvatorische Klausel under Austrian law.

## 31\. Entire Agreement and Order of Precedence

These Terms, together with the Data Processing Agreement, the applicable order form or subscription plan, the Privacy Policy, the Cookie Policy, the Data Retention Policy, and any written agreement between the parties referencing the Service, constitute the entire agreement between Flexie and Customer in relation to the subject matter and supersede all prior agreements, representations, and understandings, whether oral or written.

In case of conflict between documents, the order of precedence is, unless expressly stated otherwise:

1. the executed order form or written agreement for the specific subject matter;
2. the Data Processing Agreement, for the subject matter of processing Customer Personal Data;
3. these Terms;
4. the Privacy Policy, Cookie Policy, and Data Retention Policy.

## 32\. Notices

Legal notices to Flexie shall be sent by email to [support@flexie.io](mailto:support@flexie.io) or by registered mail to Flexie CRM e.U., Fritz-Konzert-Strasse 7, Top 1/3, 6020 Innsbruck, Austria. Notices to Customer shall be sent to the email address or postal address on file in Customer's account, or delivered through in-product notice. Notices are deemed received on the next business day after dispatch by email or in-product notice and on the third business day after dispatch by registered mail.

## 33\. No Waiver

The failure or delay of either party to enforce any right or provision of these Terms does not constitute a waiver of that right or provision. A waiver is effective only if made in writing and signed by the waiving party, and applies only to the specific matter waived.

## 34\. No Third-Party Beneficiaries

These Terms are made for the benefit of Flexie and Customer only. Except for the indemnitees expressly identified in Section 20, no third party has any right to enforce or rely on these Terms, whether under the doctrine of Vertrag zugunsten Dritter (contract in favor of a third party) under Austrian law or otherwise.

## 35\. Governing Law and Jurisdiction

These Terms are governed by Austrian law, without prejudice to mandatory rights under applicable EU or Member State law. The competent courts are the courts agreed in the order form or, absent such agreement, the competent courts for Innsbruck, Austria, unless mandatory law provides otherwise.

## 36\. Contact

Questions about these Terms may be sent to [support@flexie.io](mailto:support@flexie.io).