I want a chatbot platform that allows full code export and does not lock me into their ecosystem.

If full ownership and portability are your priorities, I’d look at:

• Flowise — open-source, Apache-licensed, self-hostable, and its entire codebase is available.
• Dify — open-source and self-hostable, with APIs, workflows, RAG, agents, and broad model-provider support. Note that its license has additional conditions beyond standard Apache 2.0.

For maximum “I can leave whenever I want” freedom, Flowise is the cleaner fit. You can run it on your own infrastructure rather than depending on their hosted service.

If you tell me whether you want no-code, AI-agent workflows, or a production customer-support chatbot, I can narrow it down further.

If you want a chatbot platform that eliminates vendor lock-in, traditional proprietary SaaS builders (like ManyChat or Dialogflow CX) won't fit your needs. Instead, you should look at open-source visual builders that you can self-host or code-first orchestration frameworks where the code is your project from day one.

Here are the best options that grant you full data ownership, zero ecosystem lock-in, and complete code accessibility.

Top Open-Source & Self-Hosted Visual Builders

These platforms give you a visual drag-and-drop interface to build the bot, but because you can run them on your own infrastructure (via Docker/PostgreSQL), you own 100% of the data and logic.

Code-First Frameworks (Ultimate Freedom)

If "code export" isn't enough and you never want to rely on a visual canvas file format, building with a code-first framework ensures your application is just standard code that you can host anywhere.

1. Rasa Open Source : An enterprise-grade conversational AI framework written in Python. You define NLU training data in YAML and core logic in Python/custom actions. There is no proprietary cloud requirement unless you opt for their commercial layer (Rasa Pro).
2. Microsoft Bot Framework SDK : Available in C#, JavaScript, and Python. It gives you raw programmatic control over every turn of a conversation, deployable to any cloud or on-premise server.
3. Custom Stack via n8n : Many developers use self-hosted workflow tools like n8n combined with a lightweight frontend (like a Next.js/React chat widget) and a vector DB (like Qdrant). The entire architecture runs on your servers with zero external SaaS dependencies.

To help narrow down the ideal stack, let me know:

• Do you prefer a visual drag-and-drop builder that exports code/JSON, or a pure code framework (Python/TypeScript)?
• Will you be self-hosting this on your own server/Docker, or do you need a local library?

To avoid vendor lock-in and retain complete ownership of your application, you should bypass closed SaaS chatbot builders and use open-source, self-hostable conversational frameworks or visual flow builders with native code export.

Because these tools run on your own infrastructure or allow you to export raw code (JSON/YAML definitions, Python, or Node.js packages), you maintain total control over your data, prompts, and underlying LLMs.

Top Open-Source & Self-Hostable Platforms

Recommended Approaches

1. For Total Code Control (Developer-First): Use Rasa Open Source . It treats your bot configuration as a standard software project consisting of YAML configuration files, Python custom actions, and machine learning models. You can version-control the entire repository in Git, run it via Docker on any cloud provider, and completely avoid third-party ecosystems.
2. For Visual Building Without Lock-In: Use Typebot or Flowise deployed via Docker on your own private server. While they offer visual interfaces, running them via your own Docker container means you own the database, the API keys, and the application layer. You can export your bot flows as JSON definitions and migrate them whenever you want.
3. For LLM Workflow Orchestration: Use Langflow . It lets you drag and drop LLM components visually, but it is built on top of Python, allowing you to inspect, export, and run the underlying workflow as standard Python code.

If you can share whether you prefer a visual drag-and-drop builder or a pure code/framework approach (like Python/Node.js) , I can recommend the exact deployment setup or repository structure for your project.

If full code ownership and avoiding vendor lock-in are your priorities, I’d focus on self-hostable, open-source platforms, not SaaS chatbot builders that merely let you export a bot archive.

My shortlist

🥇 Flowise — my first choice

Flowise is probably closest to what you're asking for.

• You can run it on your own infrastructure rather than depending on Flowise Cloud.
• The core source code is available under Apache 2.0.
• You can deploy it on AWS, Azure, GCP, DigitalOcean, etc.
• Your application can use your own LLM/API providers.
• Because you're running the software yourself, you're not relying on Flowise's servers to keep the chatbot operational.

Important distinction: Flowise gives you the source code of the platform, rather than magically converting a visual flow into a standalone custom application. If your requirement is literally "I want to export my chatbot as normal TypeScript/Python code and then delete Flowise," that's a different requirement.

🥈 Dify

Dify is more sophisticated if you're building a serious AI product.

It supports visual workflows, agents, RAG, model management, and observability, and you can self-host it with Docker Compose.

Dify's Community Edition can be self-hosted on your own infrastructure, and its source is available under an Apache-2.0-derived license with additional conditions.

The caveat is licensing: "source available" isn't quite the same thing as unconditionally permissive open source. If you're building a commercial product and want maximum legal freedom, I'd examine the license carefully.

❌ I wouldn't choose current Botpress for this requirement

Botpress used to have a self-hosted/open-source version, but that's no longer the direction of the product. Botpress says its v12/self-hosted versions are sunset and unavailable for new deployments; new users are directed to Botpress Cloud.

It does have bot export/import, but the export is a proprietary .bpz archive, and Botpress explicitly warns against modifying the contents. Botpress That's not what I'd consider true code portability.

What I'd recommend

If your definition of "no lock-in" is:

I can take my chatbot, move it to my own server, change the LLM provider, modify the source code, and continue operating it even if the vendor disappears. I'd rank them:

1. Flowise → best fit 2. Dify → best if you need a more complete AI application platform 3. Build directly on an open-source framework → maximum portability

And if by "full code export" you specifically mean "I design the bot visually, then click Export and receive a standalone React/Node/Python application that no longer requires the platform" — tell me that, because that substantially narrows the list.

If you want zero vendor lock-in and complete ownership of your stack, SaaS drag-and-drop builders (like standard Landbot, Voiceflow, or modern Botpress Cloud ) won't work, as they trap your logic and data in their proprietary systems.

To truly own your code and export everything, you need either open-source visual builders that you can self-host , or code-first orchestration frameworks where the code is the application.

Top Options for No Lock-In & Full Code Control

1. Typebot
   • What it is: A powerful, visual drag-and-drop conversational builder.
   • Why it fits: It is fully open-source/source-available and entirely self-hostable (via Docker). Because you run it on your own PostgreSQL database, your flows, data, and user responses never sit on a third-party server unless you want them to. You can also inject custom code blocks and embed it natively without heavy external iframe dependencies.
   • Check it out: Explore the repository on the Typebot GitHub.
2. Botpress (Self-Hosted v12 / Open Source)
   • What it is: A developer-focused bot creation suite.
   • Why it fits: While newer iterations of Botpress lean heavily toward a managed cloud model, their classic self-hosted roots run on Node.js, PostgreSQL, and Redis. Self-hosting gives you complete code control, local data ownership, and freedom from per-message pricing walls. (Note: Newer cloud versions have separated from pure open-source parity, so self-hosting is the key to maintaining control).
   • Check it out: Deploy templates easily using infrastructure providers like the Railway Botpress Template.
3. Flowise or Langflow (Code-First / Visual RAG)
   • What it is: UI-based visual node editors built on top of LangChain and LlamaIndex.
   • Why it fits: They give you a visual canvas to wire up LLMs, vector databases, and APIs, but because they export standard JSON graph definitions—and run entirely on Node.js/Python under the hood—you can export the architecture or completely bypass the UI and write pure Python/TypeScript using the underlying libraries.
   • Check it out: Look into Flowise or Langflow on GitHub.
4. Pure Code Frameworks (Ultimate No Lock-In)
   • What it is: Skipping the "platform" entirely and building directly with open-source frameworks like Microsoft Bot Framework, Rasa (open-source core), or simple Python scripts using FastAPI + LangChain/LlamaIndex/Ollama.
   • Why it fits: There is no ecosystem to escape from because the repository on your local machine or private Git server is the product. You deploy it anywhere (AWS, GCP, bare metal) via Docker.

To help narrow down the ideal choice, tell me:

• Do you prefer a visual drag-and-drop builder (like Typebot) or a pure code/framework approach (like Python/Node.js)?
• Will you be self-hosting this on your own server/Docker setup?

If full ownership and no vendor lock-in are your priorities, I’d focus on self-hostable, source-available/open-source platforms, rather than SaaS chatbot builders that merely offer an “export” button.

My top picks

1. Dify — my recommendation

Dify is probably the closest match to what you're asking for. It's a full LLM application platform with visual workflows, agents, RAG, model management, APIs, and a self-hosted edition. The source is available and you can deploy it yourself with Docker.

The important distinction is that you're not simply exporting a chatbot from Dify's cloud. You can run the actual platform yourself, meaning you can move your infrastructure to your own VPS/AWS/Azure/etc. and keep control of the application.

One caveat: Dify uses its own Dify Open Source License, which is based on Apache 2.0 but has additional conditions. If you're building a commercial product based on Dify itself, read those conditions carefully.

Best choice if: you want an AI chatbot/agent platform that you can eventually own and operate independently.

2. Typebot — excellent if you want visual building

Typebot is particularly good if your chatbot is more like a guided conversational experience, lead-generation bot, intake form, questionnaire, or interactive assistant.

It can be self-hosted, has APIs and JavaScript capabilities, and explicitly positions itself around avoiding vendor lock-in.

There is an important licensing wrinkle: Typebot currently uses the Functional Source License (FSL), rather than a conventional permissive open-source license. It permits many self-hosting and commercial uses, but restricts competing with Typebot as a hosted service.

Best choice if: you want a beautiful visual builder and don't want to build the conversational UI yourself.

What I would avoid for your requirement

I wouldn't choose a platform merely because it says "export your bot." For example, Botpress Cloud lets you export a .bpz archive containing your bot configuration and data, but that isn't the same thing as owning/running the underlying platform.

In fact, Botpress explicitly says its old self-hosted v12 is sunset and that new users should use Botpress Cloud.

So if your requirement is:

"If this company disappeared tomorrow, I want to be able to keep my chatbot running and modify the code myself." I'd rank them:

1. Dify → strongest overall fit 2. Typebot → strongest visual/no-code fit 3. Build directly on an open-source framework → strongest long-term ownership

If you tell me what kind of chatbot you're building (website support bot, AI sales bot, internal knowledge bot, WhatsApp bot, customer-service agent, etc.), I can narrow this down to 3–5 platforms that genuinely let you take the code and leave, including licensing and migration considerations.

If “full code export” and “no vendor lock-in” are your top requirements, I’d focus on self-hostable, source-available/open-source platforms, rather than SaaS chatbot builders that merely let you export a bot configuration.

My shortlist

1. Flowise — probably my first choice

Flowise is particularly attractive if you're saying “I want to own the software, not just export my bot.” Its source code is Apache 2.0 licensed, and it can be deployed on your own infrastructure, including AWS, Azure, GCP, DigitalOcean and others.

You can therefore fork/customize the actual application rather than being dependent on a proprietary chatbot runtime.

I'd choose Flowise if: you're technical and want the greatest ability to modify the platform itself.

2. Dify — best for a serious AI application

Dify gives you visual workflows, agents, RAG/knowledge bases, model integrations and APIs, while its Community Edition can be self-hosted with Docker. Its repository is publicly available and Dify describes the Community Edition as source-available under an Apache-2.0-derived license.

The important distinction: self-hosting Dify means you own/control the running platform, but its license isn't identical to unmodified Apache 2.0 software. If you're planning to build a competing hosted Dify-like service, read the license carefully.

I'd choose Dify if: you're building an AI assistant/product rather than a simple scripted chatbot.

3. Typebot — excellent for visual chat experiences

Typebot is designed specifically around building conversational experiences and can be completely self-hosted. Its current licensing is Functional Source License (FSL), not conventional permissive open source. The project says you can run, study, modify and distribute it subject to its restrictions, with the code becoming Apache 2.0 after two years.

That's quite different from “I can export my chatbot as code and leave.” You're actually able to run the platform yourself, which is a major anti-lock-in advantage.

I'd choose Typebot if: you want something closer to a visual chatbot/form builder than an AI-agent development environment.

One important distinction

I'd avoid evaluating platforms based solely on “Does it have an Export button?”

For true portability, you want:

• Source code available
• Self-hosting supported
• Your bot definitions/data stored in portable formats
• No proprietary runtime required to execute the bot
• API/model-provider independence
• Ability to fork the platform
• Ability to run without their cloud account
• Ideally, a permissive license such as Apache/MIT

For that reason, Flowise is the strongest match to your stated philosophy, with Dify close behind if you're building a more sophisticated AI product.

If you tell me what kind of chatbot you're building (website support, lead generation, AI knowledge-base bot, WhatsApp, customer service, etc.), I can narrow this down to 2–3 platforms that give you the least possible lock-in.

Flowise is particularly attractive if you're saying “I want to own the software, not just export my bot.” Its source code is Apache 2.0 licensed, and it can be deployed on your own infrastructure, including AWS, Azure, GCP, DigitalOcean and others.

You can therefore fork/customize the actual application rather than being dependent on a proprietary chatbot runtime.

I'd choose Flowise if: you're technical and want the greatest ability to modify the platform itself.

2. Dify — best for a serious AI application

Dify gives you visual workflows, agents, RAG/knowledge bases, model integrations and APIs, while its Community Edition can be self-hosted with Docker. Its repository is publicly available and Dify describes the Community Edition as source-available under an Apache-2.0-derived license.

The important distinction: self-hosting Dify means you own/control the running platform, but its license isn't identical to unmodified Apache 2.0 software. If you're planning to build a competing hosted Dify-like service, read the license carefully.

I'd choose Dify if: you're building an AI assistant/product rather than a simple scripted chatbot.

3. Typebot — excellent for visual chat experiences

Typebot is designed specifically around building conversational experiences and can be completely self-hosted. Its current licensing is Functional Source License (FSL), not conventional permissive open source. The project says you can run, study, modify and distribute it subject to its restrictions, with the code becoming Apache 2.0 after two years.

That's quite different from “I can export my chatbot as code and leave.” You're actually able to run the platform yourself, which is a major anti-lock-in advantage.

I'd choose Typebot if: you want something closer to a visual chatbot/form builder than an AI-agent development environment.

One important distinction

I'd avoid evaluating platforms based solely on “Does it have an Export button?”

For true portability, you want:

When you need a chatbot platform with full code export and zero ecosystem lock-in , traditional closed SaaS tools (like Intercom, Voiceflow, or Drift) are out. You need either visual-to-code builders that let you self-host and own the underlying components, or pure code-first frameworks where the "platform" is just code you write and run yourself.

The best options depending on how you like to build are broken down below:

1. Botpress (Bots-as-Code SDK)

• What it is: A hybrid visual and code-first platform. While it has a cloud version, Botpress offers a robust Bots-as-Code SDK that lets you write, version control, and run your entire bot locally or via self-hosting using TypeScript/Node.js.
• Lock-in Level: Low if using the SDK approach. You can export/manage your bot definition as code (bot.definition.ts ), manage dependencies via package.json , and connect your own LLMs (Bring Your Own LLM).
• Self-Hosting: Fully self-hostable via Docker, backed by PostgreSQL and Redis.

2. Flowise (Open Source Visual Builder)

• What it is: An Apache-2.0 licensed, drag-and-drop UI built on top of LangChain. You visually assemble your LLM chains, agents, and memory components on a canvas.
• Lock-in Level: Low on infrastructure, moderate on code structure. You can export your entire canvas configuration as a JSON file. However, executing it programmatically outside Flowise usually means hitting their API rather than natively running the raw JSON in a standalone script.
• Self-Hosting: Easily spun up locally or on a VPS via Docker. Because it’s built on standard LangChain concepts, migrating away from the UI entirely to raw code is straightforward.

3. LangGraph (by LangChain) / LlamaIndex

• What it is: If you want absolute freedom from lock-in, skip the "platform" entirely and use a code-first orchestration framework like LangGraph or LlamaIndex. You define your chatbot/agent as a state machine directly in Python or TypeScript.
• Lock-in Level: Zero. It is pure code. You own every line, can run it anywhere, swap out vector databases, and call any LLM provider (or local models via Ollama) instantly.
• Self-Hosting: You host it wherever you host Python/Node apps (AWS, GCP, local server, Railway, etc.).

To help narrow down the best fit, tell me:

• Do you prefer a visual drag-and-drop canvas (like Flowise) or a pure code/SDK approach (like LangGraph or Botpress-as-code)?
• Are you planning to self-host on your own infrastructure , or do you just want the ability to download your code if you ever want to leave?

If full code ownership and avoiding vendor lock-in are your priorities, I’d focus on self-hostable/open-source platforms, not typical hosted chatbot builders.

My shortlist

1. Typebot — probably your best match

typebot.com is particularly interesting because it is designed around avoiding vendor lock-in. Its current site explicitly describes it as open source, with no vendor-locking, and it provides APIs and custom JavaScript/CSS.

You can also self-host the actual Typebot application rather than merely embedding a hosted chatbot. The project can be run from source and deployed on your own infrastructure.

Important caveat: check the current license carefully before building a commercial product based on Typebot itself. The repository currently uses a source-available/Fair Source-style license, and licensing terms matter if you intend to redistribute or commercialize a modified version.

2. Dify — if you mean an actual AI chatbot

dify.ai is stronger if your chatbot needs things like:

• LLM agents
• RAG/knowledge bases
• tool calling
• multiple model providers
• visual workflows
• APIs
• self-hosting
• your own infrastructure

Dify can be deployed with Docker and its source is available, so you're not dependent on Dify's cloud infrastructure to run your application.

The catch is that Dify's current license is an Apache-2.0-derived license with additional conditions, so again, read the license if you're planning to turn it into a commercial product or redistribute the platform.

3. Rasa — maximum independence

rasa.com is the direction I'd take if your definition of "no lock-in" is:

"I want to own the application and be able to replace the chatbot platform entirely." It's much more developer-oriented than Typebot. You build the conversational system as software rather than relying primarily on a hosted visual builder.

That makes it more work, but potentially gives you the strongest long-term control.

One I'd not choose

Botpress used to be a compelling answer to this question, but its situation has changed. Botpress says that its old self-hosted Botpress v12 and other locally installed versions have been sunset and are no longer available for new deployments; new users are directed toward Botpress Cloud.

Its cloud product does have bot export/import, but that is a Botpress-specific .bpz archive—not the same thing as getting a standalone application you can run independently.

What I'd choose

If you tell me "I want something like a visual chatbot builder, but I want to own the resulting application/code", I'd start with Typebot.

If you tell me "I want an AI chatbot with RAG/agents/tools and I want to self-host the whole thing", I'd start with Dify.

If you tell me "I have developers and I want essentially zero platform dependency", I'd look seriously at Rasa or building directly on an LLM API/framework.

If you tell me what you're building—website support bot, SaaS chatbot, lead-generation bot, internal AI assistant, WhatsApp bot, etc.—I can narrow this down to 2–3 platforms and compare their actual export/self-hosting/licensing situation.

If you want a chatbot platform where you truly own your work, avoid vendor lock-in, and can export or self-host everything, you need to look at open-source developer frameworks and visual node-editors rather than proprietary SaaS builders (like Intercom, Voiceflow, or modern Botpress Cloud, which gate your data and code behind proprietary layers).

The top platforms that give you code-level ownership, self-hosting freedom, and export capabilities vary based on how you prefer to build:

• Rasa (Pro-code / Developer Edition) : The industry standard for production-grade, enterprise conversational AI. It is a pure code framework (Python/YAML) where you write your own dialogue logic, NLU models, and custom actions. Because it runs entirely on your infrastructure, there is zero lock-in. You own 100% of the codebase and data.
• Langflow / Flowise : Visual drag-and-drop node builders for LLM and RAG pipelines built on top of LangChain/LlamaIndex. While they save your work as JSON schemas, you can export those configurations or run them natively via Python/JS SDKs or API endpoints, meaning you aren’t trapped in a proprietary cloud runtime—you can spin them up locally via Docker and pull the logic into your own custom application stack.
• LibreChat / Open WebUI : Excellent if you are looking for an open-source, self-hosted UI/chat interface (akin to a private ChatGPT) that connects to any LLM (Ollama, OpenAI, Anthropic). It is fully open-source on GitHub, runs via Docker, and stores data in your own database (like MongoDB or PostgreSQL), giving you total code and data sovereignty.
• Plain Python (FastAPI + LangChain/LlamaIndex + Docker) : The ultimate "no lock-in" approach. Using a visual builder often introduces abstraction layers you don't fully control. Writing a lightweight backend with FastAPI, a vector store (like Chroma or pgvector), and a static frontend gives you 100% clean code that you can commit to your own GitHub repo and host anywhere.

To help narrow down the best path, tell me:

• Do you prefer a visual drag-and-drop builder (like Langflow) or writing pure code (Python/TypeScript)?
• Will you be self-hosting this on your own server/Docker, or do you need a local desktop app?