The essentials · 30-second read
Directual is a no-code backend for apps and AI agents. Per app, billed yearly: Startup $39, Pro $175, Business $840 a month ($49, $249, $1,199 monthly). 14-day trial.
- Directual combines a NoSQL database with built-in vector search, visual scenarios for business logic, an API builder (REST, GraphQL, webhooks), file storage and a UI builder for internal apps.
- Pricing page on 18 November 2026, per app, excluding tax: Startup $39, Pro $175, Business $840 a month billed yearly; $49, $249 and $1,199 billed monthly. Team plan $59 per developer seat billed yearly.
- Active in 2026: the blog published on 11 November 2026, and the platform now leads with AI agents, LLM integration and Telegram Mini Apps.
- Our verdict: capable for logic-heavy backends and AI workflows, but expensive and less widespread than Xano or Supabase, which we usually suggest first.
Summarize this page with AI
Directual is a no-code platform that focuses on what most visual builders keep simple: the backend. You model data, write business logic as visual scenarios and publish API endpoints, and in 2026 the platform leads with AI agents built on top of that foundation. It is less known in Western Europe than Xano or Supabase, and its pricing is per app. This page explains what Directual does today, what its plans cost, what each plan's limits mean in practice and when we would recommend it. Checks were made on 18 November 2026.
Status note (18 November 2026): Directual is active. Its blog published a post on 11 November 2026 about running AI agent loops with Directual, the site footer reads "© 2026 Directual", and the home page now leads with "Build AI-systems without coding". If you knew Directual as a pure no-code backend, the core is the same, but the message has shifted to AI.
01What is Directual?
Directual describes itself as "a full-stack no-code platform with database, vector search, API, file storage and UI builder". Its documentation presents four building blocks. The database is flexible NoSQL storage with a built-in vector database for semantic queries and AI features. Scenarios, which the documentation calls "the heart of the platform", are a visual workflow engine for real-time events and scheduled jobs. The API builder publishes REST and GraphQL endpoints and webhooks, with role-based access, filtering, sorting and Swagger documentation. The UI builder creates internal apps from forms, tables and cards.

On top of these blocks, Directual offers solution pages for AI agents (connecting language models to your app so they analyse data, perform tasks and interact with users), Telegram Mini Apps and chatbots, and blockchain and Web3 features. Directual claims more than 30,000 entrepreneurs, agencies and companies as users, and publishes case studies such as a learning management system with 47,000 students.
02How we look at Directual at BeBranded
Directual is not part of our stack. The backends we know best are Supabase, which hosts the PostgreSQL database of our own site and is in our public toolbox, and visual backends such as Xano that we recommend to no-code teams. Here is how we position Directual when a client asks.
- We see Directual as an option for a logic-heavy backend built by a technical maker who prefers visual scenarios to code, especially when AI agents need to work on the data with permissions and approvals.
- We recommend keeping it when an application already runs well on Directual: the platform is active, and a migration of scenarios and APIs is real work.
- We usually suggest something else first for a new project: Supabase for a custom application on PostgreSQL, Xano for a visual backend behind a no-code front end. Both have larger communities and more predictable entry prices.
- Our usual role: scoping the architecture and building the backend and integrations in web app, MVP, internal tool or AI agent projects.
03Key features
- Database: NoSQL structures with fields and relations, plus a built-in vector database for semantic search.
- Scenarios: visual workflows triggered by events, schedules or API requests, with synchronous logic on any endpoint.
- API builder: REST and GraphQL endpoints, webhooks, role-based access, filters and Swagger documentation.
- UI builder: mobile-friendly pages for internal apps and portals, built from forms, tables and cards.
- AI agents: LLM integration in scenarios, with the platform handling history, data access, permissions and approvals.
- File storage: from 15 GB per app on Startup to 300 GB on Business.
- Plugins and integrations: premium plugins on all plans and HTTP requests from scenarios to external services.
- Environments and SDK: dev and prod environments and an advanced SDK on Business.
04Use cases
An AI agent that works on company data
A company wants an assistant that reads its records, drafts answers, and performs actions only with approval. Directual stores the data, gives the agent access through scenarios and keeps history and permissions. What to know: define precisely what the agent may do on its own and what needs a human check, and monitor model costs, which are separate from Directual's plan.
A backend for a no-code front end
A team builds its interface in a visual tool and needs a backend with real business rules: pricing calculations, status changes, notifications. Directual publishes those rules as API endpoints. What to know: check request limits against expected traffic, since Startup allows 3,000 POST requests a month.
An internal portal or back office
An operations team needs a tool to manage records, roles and approvals. Directual's UI builder creates pages from forms, tables and cards on top of the same data and scenarios. What to know: for a simple internal tool, Softr or Glide will be cheaper and quicker; Directual makes sense when the logic is substantial.
A Telegram Mini App or chatbot
Directual has dedicated solutions for Telegram Mini Apps and chatbots, which reach users inside Telegram without an app store. What to know: Telegram's own rules and payment options apply, so read them before you design the product.
An agency delivering several client backends
The Team plan gives agencies one Pro-Sandbox app per developer seat for building and, according to the pricing page, up to 50% of their clients' license payments. What to know: each client app then needs its own paid plan, so include it in the client's budget.
05Integrations
Directual connects mainly through its API builder and its scenarios. Any front end or service that calls REST or GraphQL APIs can read and write Directual data, and scenarios can send HTTP requests to external services or receive webhooks, which also works with automation tools such as Make, Zapier or n8n. Premium plugins are included on every plan, and the platform integrates language models for AI features. We did not find a current public list of plugins on the site, so check the connector you need during the trial.
06Directual pricing in 2026
Prices checked on directual.com/pricing on 18 November 2026. The page shows US dollars, per app and per month, with yearly or monthly billing, and states that applicable taxes are added at checkout.

| Plan | |||||
|---|---|---|---|---|---|
| Startup | Per app a month (yearly / monthly) $39 / $49 | Processing operations a month 30,000 | Requests (GET / POST) a month 30,000 / 3,000 | Speed, storage 10 RPS, 15 GB files, 200 MB database | Highlights 14-day free trial, unlimited scenarios, endpoints and pages, premium plugins |
| Pro | Per app a month (yearly / monthly) $175 / $249 | Processing operations a month 500,000 | Requests (GET / POST) a month 500,000 / 50,000 | Speed, storage 100 RPS, 75 GB, 1 GB | Highlights Custom domain with SSL, hosting region, advanced security, 98% SLA, $1 one-month trial |
| Business | Per app a month (yearly / monthly) $840 / $1,199 | Processing operations a month 2,000,000 | Requests (GET / POST) a month 2,000,000 / 200,000 | Speed, storage 1,000 RPS, 300 GB, 5 GB | Highlights Dev and prod environments, advanced SDK, 99.9% SLA, daily backups, consultations |
| Team | Per app a month (yearly / monthly) $59 / $74 per developer seat | Processing operations a month Pro-Sandbox: 50,000 | Requests (GET / POST) a month 50,000 / 5,000 | Speed, storage 10 RPS, 15 GB, 500 MB | Highlights One Pro-Sandbox app per seat, premium support, partner programme |
Each plan also counts sync operations and scenario HTTP requests (3,000 on Startup, 50,000 on Pro, 200,000 on Business). Extra resources are available on demand, with cheaper rates on higher plans. Model costs for AI features are not part of these prices.
Is Directual free? No permanent free plan is shown for a live app. You can try Startup for 14 days without a card, or Pro for one month at $1, and the Team plan includes sandbox apps for developers. A small app in production starts at $39 a month on yearly billing, and the jump to Pro ($175) comes quickly if you need a custom domain or more than 3,000 POST requests a month.
07Pros and cons
Advantages
- A backend built for logic: visual scenarios, events, schedules and synchronous endpoints.
- REST, GraphQL and webhooks with role-based access and Swagger documentation.
- Built-in vector search and AI agent features without another service.
- A UI builder for internal apps on the same data.
- Active development and frequent publications in 2026.
Drawbacks
- Expensive as soon as you leave Startup: $175 a month per app for a custom domain.
- Tight limits on Startup, especially 3,000 POST requests a month.
- A smaller community in Europe and fewer tutorials than Xano, Supabase or Bubble.
- Real backend concepts: not a tool for complete beginners.
- Lock-in: scenarios and data structures live in Directual, and moving them is a project.
08Our verdict
Who it's for
- Technical makers who want a visual backend with heavy business logic.
- Companies building AI agents on their own data with permissions and approvals.
- Agencies that already deliver Directual projects and use the Team plan.
Who it's not for
- Developers who want SQL, open source and portability: Supabase.
- No-code teams that want the most common visual backend: Xano.
- Simple portals and internal tools on existing data: Softr or Glide.
- Customer-facing web apps built in one visual tool: Bubble.
09Directual alternatives
| Tool | |||
|---|---|---|---|
| Directual | Best for No-code backend with scenarios and AI agents | Free plan 14-day trial | Paid from $39 a month per app, billed yearly |
| Xano | Best for Visual backend and APIs for no-code fronts | Free plan For testing | Paid from $85 a month billed yearly |
| Supabase | Best for PostgreSQL, auth, storage, APIs, open source | Free plan 2 projects | Paid from $25 a month (Pro) |
| Backendless | Best for Visual backend with real-time and self-hosting | Free plan Yes | Paid from $15 a month (Scale) |
| Bubble | Best for Full-stack web apps in one visual tool | Free plan Yes, to build | Paid from $32 a month billed yearly |
Our rule: Supabase for a new custom application, Xano for a visual backend behind a no-code front end such as WeWeb or FlutterFlow, Bubble when the whole web app should live in one tool. Consider Directual when the backend logic and AI agents are the heart of the project and the team likes visual scenarios. Our guide on how to select the right no-code tools lists the questions to ask first.
10Directual vs Xano
Directual and Xano answer the same need: a backend without writing server code. Xano is built around PostgreSQL and its function stack for API logic, and it has become the reference backend in many no-code communities, with connectors and tutorials for most visual front ends. Directual is built around NoSQL structures and scenarios, adds a UI builder, a vector database and AI agent features, and bills per app.
On price, Directual Startup ($39 a month billed yearly) is cheaper than Xano Essential ($85), but its Startup limits are tight and Pro costs $175 a month. On ecosystem, Xano is more widespread, which makes hiring help and finding answers easier. On AI, Directual offers more out of the box. Our advice: Xano for a classic backend behind a no-code front end, Directual when AI agents and complex scenarios are central and you have tested its limits during the trial.
11Getting started with Directual
- Start the 14-day Startup trial and model two or three core data structures with their relations.
- Build one scenario end to end, for example a status change that sends a notification, to learn the logic engine.
- Publish an endpoint and call it from your front end or an API client, with roles applied.
- Estimate your monthly volume of operations and POST requests before choosing between Startup and Pro.
- Add AI features last, once the data and permissions are clear, and track model costs separately.
- Document scenarios and endpoints so the backend does not depend on one person. If you want a second opinion on the architecture, our project scoping service compares the options with you.


