When is the Tyk open source gateway enough, and when do you need Tyk Self-Managed?
If your APIs need a gateway and your team is comfortable managing configuration as code, the open source Tyk Gateway with Redis may be enough. If you need a visual management console, a developer portal for external or internal consumers, or licensed Kubernetes-native declarative management, you need the licensed layer. The gateway itself is MPL-2.0 licensed and documents JWT and bearer tokens, Basic Auth, client certificates, rate limiting and quotas, API versioning, per-version and per-operation access control, IP allowlisting and hitless configuration reloads. Plugins can be written in Python, JavaScript, Go or any language that supports gRPC, so a team can extend the middleware chain without buying anything. Confirm with your own architects that file-based or API-driven configuration fits how your change process works, because the open source documentation does not describe a graphical administration console.
The paid stack becomes relevant when the operating model changes. Tyk Self-Managed adds the Tyk Dashboard, the Developer Portal, Tyk Pump, PostgreSQL and a license for each of these components, and the Tyk Operator for Kubernetes requires a license as well. Ask Tyk for a written list of which components each licensed feature depends on, since a portal requirement alone can pull in several of them. The alternative to self-managing that stack is Tyk Cloud, which hosts the full stack and offers a free trial. Before deciding, check the gateway release you plan to run against the current Tyk GitHub releases page, where Tyk Gateway v5.15.1 was published on October 2, 2026, and confirm your Redis and deployment method with the tyk-oss Helm chart or package options listed in the Tyk README.
Which capabilities sit in the free gateway and which in the licensed stack
This table compares the capabilities Tyk documents for the open source gateway with those in the licensed Self-Managed platform and add-ons. Read each row as a question about where a feature lives, not a ranking. Where the public documentation does not assign a feature to an edition, the cell tells you what to confirm with Tyk before you commit.
| Capability | Open source Tyk Gateway (MPL-2.0) | Licensed Tyk Self-Managed and add-ons |
|---|---|---|
| Gateway protocols | REST with native OpenAPI support, SOAP, GraphQL, gRPC, TCP and MCP, per the Tyk README | Confirm with Tyk whether the full protocol set is identical when the gateway runs under the Dashboard |
| Authentication methods | JWT, bearer tokens, Basic Auth and client certificates | Confirm with Tyk whether any auth method is configured only through the Dashboard or the Operator |
| Rate limiting, quotas and versioning | Rate limiting, quotas, API versioning and per-version and per-operation access control are documented as gateway features | Confirm with Tyk how quotas and access control are managed and reported in the Dashboard and Developer Portal |
| Plugin languages | Middleware plugins in Python, JavaScript, Go or any language that supports gRPC | Confirm with Tyk whether the same plugin languages apply to plugins deployed through the licensed platform |
| Dashboard and Developer Portal | Not part of the open source gateway package | Part of the full Self-Managed platform, which needs a license per the Tyk README |
| Tyk Pump, Redis and PostgreSQL | The open source gateway runs with Redis | The full platform runs Tyk Pump and PostgreSQL alongside Redis, and needs a license |
| Kubernetes Operator | Not included in the open source gateway, which can be installed with the tyk-oss Helm chart | Declarative API management through the Tyk Operator requires a license per the Tyk README |
| Hosted option | Not applicable to self-hosting | Tyk Cloud manages the full stack and offers a free trial; confirm current pricing and tier limits with Tyk |
How licensing and support differ between the two editions
The open-source Gateway and the licensed Self-Managed platform sit under different terms, and the difference shows up in what you can run in production without a contract. The cards below separate the code licenses, the components that need a license, and the support and release questions to settle with Tyk before you commit.
Gateway code under MPL-2.0
The Tyk Gateway repository is licensed under the Mozilla Public License 2.0, which is a file-level copyleft license. Your team can run, modify and internally deploy the open-source Gateway under those terms, but any modified MPL-covered files you distribute must stay under MPL-2.0. Have counsel confirm how that obligation applies to your internal plugins and build pipeline.
The ee folder needs a separate license
The ee folder in the Tyk repository falls under a separate commercial Enterprise Edition license, not MPL-2.0. Build the Gateway from source without that folder if you want to stay within the open-source terms, and check the repository layout for the release you deploy before assuming a given feature is free. Ask Tyk to list which features depend on the ee code.
Self-Managed platform requires a license
The full Self-Managed stack combines the Gateway, Dashboard, Developer Portal, Tyk Pump, Redis and PostgreSQL, and the stack itself needs a license. The Dashboard and portal are where most teams feel the difference, because the open-source Gateway runs without them. Ask Tyk which components are covered, how many environments the license permits and whether non-production clusters need their own entitlement.
Operator licensing for Kubernetes
The Tyk Operator, which manages APIs declaratively on Kubernetes, requires a license. If your platform team plans GitOps-driven API configuration, that requirement applies even when the Gateway itself is open source. Confirm whether the Operator entitlement is bundled with Self-Managed or sold separately, and whether it covers the clusters you plan to run.
Support terms and response commitments
Open-source Gateway use comes without a vendor support agreement, so incident response depends on your own staff and public channels. A Self-Managed contract may add support, but the response times, severity definitions and escalation path are set in that contract. Ask Tyk for the written support terms, named severity levels and any response commitments before you rely on them in a regulated change process.
Update channels and version tracking
Tyk publishes Gateway releases on its GitHub releases page, and the latest tagged example at the time of writing is v5.15.1, published on October 2, 2026. Track that page for version awareness, but ask Tyk which release channel Self-Managed customers receive, how long each line is maintained and how security patches reach licensed deployments. Do not assume the public tag history reflects your contract's update path.
How the open source Tyk Gateway runs on its own with Redis
The open source Tyk Gateway is a self-contained data plane with Redis as its only supporting datastore. It is licensed under the Mozilla Public License 2.0, and the gateway code ships with no feature lockout, so a team can run it in production without buying anything. What it does not include is the Dashboard, the Developer Portal, Tyk Pump or PostgreSQL. Those belong to the licensed Tyk Self-Managed stack, so everything around the gateway falls to your team. The gateway can be installed with Docker, the tyk-oss Helm chart on Kubernetes, Ansible, Red Hat, CentOS or Ubuntu packages, or built from source. Pick the path that matches your existing change control, and confirm which install artifacts your security team has approved before the first build.
Without a Dashboard, configuration lives in files and API calls rather than a management console. API definitions are JSON or YAML documents loaded from the gateway's configuration directory or pushed through its management API, and a reload applies changes without dropping traffic. Keys, quotas and rate limits are created and tracked in Redis, so the operator must decide how keys are issued, rotated and revoked, and who is authorized to do it. Treat Redis as a stateful dependency with its own backup, failover and access controls, not a cache. Confirm with Tyk which Redis topology and version the open source release supports in your environment before you size the cluster.
Several capabilities that the licensed stack provides must be built or scripted in-house. Typical gaps include a self-service developer portal with sign-up and key requests, an approval workflow for new API consumers, analytics export from Redis to your SIEM or data platform, and an audit trail of who changed which definition. For example, an illustrative team might generate apps definitions from a Git repository through a CI pipeline, issue keys from an internal ticketing workflow, and forward gateway logs to its log platform. Each of these is ongoing software your team owns, so estimate the maintenance effort, and ask any implementation partner to price these components as explicit line items in a fixed-scope quote.
What each edition costs to own, and which costs are published
This table breaks down what each Tyk edition costs to run, separating the licence fee from infrastructure, operating effort and the build work for portal and analytics. Tyk does not publish licence prices in the sources we rely on, so the licence row points to a written quote, while the other rows show what you can plan for yourself.
| Cost component | Tyk open source gateway with Redis | Tyk Self-Managed (Dashboard, Developer Portal, Pump, PostgreSQL) |
|---|---|---|
| Licence fee | None for the MPL-2.0 gateway code, outside the separately licensed ee folder | Commercial licence required, price not published; request a written quote covering Dashboard, Portal, Pump and any Operator use |
| Datastores and infrastructure | Redis hosting, sized to your request volume and key count; you own backups and failover | Redis plus PostgreSQL, plus hosts for Dashboard, Portal and Pump; cost rises with environments and high availability design |
| Upgrades and backups | Your team tests gateway releases and Redis persistence settings | Your team also upgrades Dashboard, Portal, Pump and PostgreSQL, and tests backup and restore for each |
| Portal and analytics build | Often custom: you build any developer portal and analytics pipeline yourself | Developer Portal and Pump are included in the licensed platform, but you still configure catalogs, onboarding and reporting |
| Operator and Kubernetes tooling | Open source Helm chart (tyk-oss) available; declarative management is your responsibility | Tyk Operator requires a licence, so confirm its inclusion in any quote |
| Hosted alternative | Not applicable; you run the stack in your own infrastructure | Tyk Cloud manages the full stack and offers a free trial; ask for its commercial terms and data residency options |
When the licensed Dashboard and portal justify the spend
The licensed layer earns its cost when the number of people managing APIs grows faster than the number of engineers who can edit configuration by hand. If many API owners need a self-service developer portal, a governed API lifecycle, or a single place to see who consumes what, the Tyk Self-Managed stack with the Dashboard, Developer Portal, Tyk Pump and PostgreSQL covers those jobs in one product. The open source Tyk Gateway with Redis can enforce keys, quotas and per-version access, but it does not give those owners a management interface or a portal. A Kubernetes-native team that wants API definitions managed as declarative resources should also price the Tyk Operator, which requires a license. Teams that prefer not to run the management stack at all can evaluate Tyk Cloud, which is described as managing the full stack and offers a free trial. Confirm with Tyk which features each tier includes, since this page relies only on the license terms the sources state.
A platform team with strong automation and a small API catalog can reasonably stay on the open source gateway. In that setup, API definitions live in version-controlled files, changes flow through CI, and keys and quotas are issued by a script or an internal service that the team already runs. The MPL-2.0 gateway supports JWT, bearer tokens, Basic Auth, client certificates, rate limiting, quotas, versioning, IP allowlisting and hitless reloads, and plugins can be written in Python, JavaScript, Go or any language that supports gRPC. The trade-off is that the team builds and maintains whatever the Dashboard and portal would have provided, including onboarding workflows, audit trails and documentation for consumers. Before committing, list those internal tools and estimate the engineering time they need, then compare that figure with a written quote for the licensed components.
Put the decision in writing before the first license conversation. Name the number of API owners who need portal access, the approval steps a new API must pass, and whether auditors will ask to see who changed a policy and when. If those answers point to self-service and governance, the licensed stack is the more direct path. If they point to a few owners and a mature pipeline, the open source gateway may be enough for now, and the team can add the commercial layer later if the catalog grows. Ask Tyk to confirm the current Dashboard and Developer Portal features in each edition, the license terms that apply to production use, and the support scope, and ask for the same answers in writing from any implementation partner you consider.
How to move from the open source gateway to Tyk Self-Managed, or back
The sequence moves API traffic, keys and policies from the MPL-2.0 gateway to a licensed management layer without interrupting live traffic. It also leaves a tested path back to the open source gateway if license scope changes.
Inventory APIs, keys and plugins
The platform team lists every API served by the running gateway, with its version, authentication method (JWT, bearer tokens, Basic Auth or client certificates), key holders, rate limits and quotas, IP allowlists, and any custom middleware plugins and the language each one uses. Check the list against the live gateway configuration, not against memory or old tickets. The step is done when a reviewer signs off a single inventory that matches what the gateway actually serves.
Confirm license scope in writing first
Before any build, ask Tyk in writing which components your intended production use requires: Dashboard, Developer Portal, Tyk Pump, the Operator for Kubernetes, and support terms. Confirm that the open source gateway code remains under MPL-2.0 and which folder carries the separate Enterprise license. Ask whether Tyk Cloud, the hosted option with a free trial, is a better fit than self-hosting the licensed stack. The step is done when the answers are recorded in the project file and approved by legal and procurement. Read the Tyk Gateway README for the component list.
Stand up PostgreSQL and Dashboard beside the gateway
Deploy PostgreSQL, Tyk Dashboard, Tyk Pump and the Developer Portal in a separate staging environment, and connect the Dashboard to a Tyk Gateway node that uses the same Redis deployment pattern as production. Production traffic stays on the existing gateway throughout. The step is done when the Dashboard can read and write gateway configuration in staging, Pump records analytics from test calls, and the production gateway shows no change in request handling.
Recreate API definitions and test parity
Recreate each API from the inventory in the Dashboard, using the staging gateway. Send the same test requests through the old and new gateway for each API, covering authentication, version routing, per-operation access control, IP allowlists, quota and rate limit behavior, and each plugin. Record any differences in response codes, headers or limits. The step is done when every API passes the parity suite or each difference has a documented fix and an owner.
Move configuration authority to the licensed layer
Make the Dashboard the only path for changing API definitions, keys and policies. Publish the API catalog through the Developer Portal, and enable Pump so analytics come from the licensed stack. If the team manages gateways declaratively in Kubernetes, confirm the Operator's license terms before adopting it. Disable direct edits to the open source gateway's local configuration files. The step is done when a change log shows every production change made through the Dashboard for a full review cycle.
Validate hitless reloads under live load
Run a load test against staging while applying configuration changes, including key revocation, a new API version, a rate limit change and a plugin update. Count failed or dropped requests during each reload, and compare results with the open source gateway under the same changes. Confirm that a bad configuration can be reverted within the Dashboard without a restart. The step is done when the test report shows zero unexpected failures during reloads and the team has accepted the revert procedure.
Plan the rollback path and cut over
Export the complete open source gateway configuration and keep it in version control so the standalone gateway can serve traffic again. Write a runbook that lists which features depend on licensed components (Dashboard-managed keys, portal publishing, Pump analytics, Operator-managed config) and what replaces each one in the open source setup. Name the owner of the go or no-go decision if license scope changes. The step is done when the rollback has been rehearsed in staging and the cutover moves production traffic in a controlled window.
What do teams ask before choosing a Tyk edition?
How much does Tyk Self-Managed cost to license?
No price appears in the sources behind this page, so the license figure has to come from a Tyk quote. The license covers the Dashboard, Developer Portal, Tyk Pump and the Operator for Kubernetes, and the Self-Managed stack also runs Redis and PostgreSQL. Your total cost has four parts: the Tyk license fee, the infrastructure for every component, the internal staff who run it, and any outside help. DeployOpen does not publish prices. Its fixed-scope engagements are quoted from a written scope. Ask Tyk whether licensing is priced per node, per API, per environment or by support tier, and ask which components each tier includes.
How long does moving from open source Tyk to Self-Managed take?
No duration is supplied for this move, so the timeline depends on your estate and should be stated in a written scope. The main drivers are the number of APIs and versions, how many policies, keys and authentication methods you already use, how much portal content must be rebuilt, the number of environments, and whether you need to keep live traffic running during cutover. Gateway configuration can usually be exported and reviewed as code, which shortens the work when it is already in version control. Ask any vendor or partner to name the inventory they need before estimating, and to list which steps are fixed and which depend on your decisions.
What does running Tyk need from our internal team?
Your team needs skills in four areas. Platform operators need Linux or Kubernetes operations, plus the ability to run Redis and, for Self-Managed, PostgreSQL with backups and upgrades. API owners need to define routes, versions, quotas and access rules. Security staff own certificates, JWT and bearer token trust, and IP allowlists. Someone must own the developer portal content and the process for onboarding consumers. The open source gateway has fewer moving parts than Self-Managed, so the staffing gap is mostly in the management layer. Confirm these skills against your own roster before choosing an edition.
Can we run the open source Tyk Gateway without outside help?
A team with platform experience can run the open source gateway without outside help, because the Gateway is MPL-2.0 licensed and can be installed with Docker, the tyk-oss Helm chart, Ansible, Red Hat, CentOS or Ubuntu packages, or from source. It runs with Redis, supports hitless configuration reloads and offers JWT, Basic Auth, client certificates, rate limiting, quotas and versioning. Your team then owns high availability, Redis backups, monitoring, certificate rotation, upgrades and the process for managing configuration without a Dashboard. If those tasks fit your capacity, you can run it alone. If they do not, outside help can be scoped in writing.
Does Tyk Cloud remove the operating effort?
Tyk Cloud removes the work of running the infrastructure, because Tyk hosts and manages the full stack and offers a free trial. It does not remove the work of designing APIs, writing policies, maintaining plugins, onboarding consumers or deciding how traffic is routed. Check where data is hosted, which regions are offered, how upgrades are scheduled, what support covers, and whether the hosted option meets the residency and audit requirements that apply to your organization. Compare those answers with the effort of running Self-Managed inside your own cloud account or data center, because the choice often turns on where regulated data is allowed to sit.
Will plugins written for the open source gateway work on Self-Managed?
Plugins should carry over in most cases, because the gateway code is MPL-2.0 licensed and plugins extend its middleware chain in Python, JavaScript, Go or any language that supports gRPC. Confirm three points before relying on this. First, the Gateway version you run must match the plugin runtime and bundle format you deploy. Second, the gateway code under the ee folder uses a separate commercial license, so check that no plugin depends on that code. Third, check whether Dashboard-managed configuration changes how plugins are registered or loaded. Test each plugin against the target version in a staging environment before cutover.
Can we start with open source and add the Dashboard later?
Yes, many teams start with the open source gateway and add licensed components later, provided the configuration is kept outside the Dashboard. The gateway already runs on Redis, so the data layer carries forward, but adding the Dashboard, Developer Portal and Pump brings PostgreSQL and a license into the stack. The switching cost depends on how much configuration you created through the API or by hand. Keeping gateway definitions in version control makes the later step smaller. Ask Tyk for its upgrade path from the open source gateway to Self-Managed, and confirm which settings must be re-entered.
What to confirm with Tyk and in your own environment before buying
Start by mapping each capability you need to a specific edition, because the public README draws a clear line only at the gateway. The Tyk Gateway is MPL-2.0 and runs with Redis, while the Dashboard, Developer Portal, Tyk Pump and PostgreSQL belong to the licensed Self-Managed stack. Ask Tyk in writing which edition carries each feature you depend on, including the controls you plan to use for per-version and per-operation access, quotas, analytics export and developer onboarding. Do not assume that a feature visible in the gateway code is available without the management layer, and do not assume the reverse. Get the answer as a feature matrix tied to the version you will deploy, such as the current Tyk Gateway releases.
Confirm the license scope for the parts that are easy to overlook. The Tyk LICENSE states that the ee folder sits under a separate commercial Enterprise Edition license, so ask which of your planned components, the Tyk Operator for Kubernetes and the Developer Portal included, are covered by which terms, and whether licenses are per node, per cluster, per environment or per API. Ask how the license is validated in air-gapped or restricted networks, what happens to running production traffic if a license lapses, and what support and update terms come with it, including the supported upgrade path between Gateway releases.
Size Redis and PostgreSQL against your own traffic rather than against a generic figure. Redis holds the state the open-source gateway relies on for quotas and rate limiting, so measure your request rate, key cardinality and failover expectations in a load test in your environment. PostgreSQL and Tyk Pump matter for analytics retention and reporting volume. Your platform team should own those numbers, and any vendor sizing guidance should be checked against them. For Tyk Cloud, confirm the hosting regions, data residency for analytics and logs, and whether your regulators or contracts require data to stay within your own infrastructure, which would rule out the hosted option regardless of price.
How DeployOpen scopes and delivers either Tyk edition
DeployOpen plans, implements, integrates, hardens, backs up, upgrades, documents and supports self-hosted platforms inside your own infrastructure, so the Tyk edition you pick is delivered in your cloud account, data center or air-gapped network. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
How we scope
- Written scope names the Tyk components in play: the Gateway with Redis alone, or the Dashboard, Developer Portal, Pump and PostgreSQL as well.
- Scope lists which licensed items are in or out, including the Tyk Operator and any Tyk Cloud use, so procurement can match the quote to the license.
- Scope records your protocols, plugin languages, identity sources and rate limit or quota rules, so the build matches real API traffic.
How we build
- Deployment follows your chosen method, such as Docker, the tyk-oss Helm chart on Kubernetes, or Linux packages, inside your own environment.
- Custom middleware plugins are built in the language your team can maintain, with tests and a documented path for upgrades.
- Security hardening covers gateway configuration, Redis access, TLS, client certificates and access control per API version and operation.
How we hand over
- Deliverables include architecture notes, configuration as code, runbooks for upgrades and restores, and evidence for your own compliance assessments.
- Knowledge transfer sessions walk your platform team through daily operations, reloads and troubleshooting before the engagement closes.
- Compliance readiness material is prepared for your auditors, who issue any reports or certifications, not DeployOpen.
How we support
- Ongoing support, upgrades and continuous security testing are available as retainers after handover.
- Upgrade planning tracks Tyk Gateway releases and your own change windows, with testing before each move to production.
- Ask any provider to confirm in writing which Tyk features need a license in your edition and which support terms apply.

