Feature Management Platforms
How do we request LaunchDarkly Enterprise pricing and what info do they need (MAU, services, environments)?
10 min read
Moving to LaunchDarkly’s Enterprise plan is usually triggered by a simple reality: you’re past the “toy project” stage, you have real blast radius to manage, and you need predictable pricing that matches how you actually run in production. To get an accurate Enterprise quote, you’ll want to come in with a clear picture of MAU, service connections, and environments so Sales can size the account in one pass instead of three back-and-forth emails.
Quick Answer: To request LaunchDarkly Enterprise pricing, contact Sales through the website and be ready with estimates for monthly active users (MAU), service connections (microservices/replicas/environments connected), and how many environments you operate. These inputs drive entitlements and ensure your quote reflects real-world usage instead of guesswork.
The Quick Overview
- What It Is: A tailored Enterprise quote for LaunchDarkly’s runtime control platform, sized to your MAU, service footprint, and observability/experimentation needs.
- Who It Is For: Engineering, product, platform, and SRE teams that need governed releases at scale—multiple services, many environments, and strict reliability or compliance requirements.
- Core Problem Solved: Avoiding surprise overages and “read-only mode” by aligning your contract with actual usage patterns across users, services, and environments.
How It Works
From a process standpoint, requesting LaunchDarkly Enterprise pricing is straightforward: you reach out to Sales, share a few key usage signals, and they translate that into entitlements (MAU, service connections, observability, experimentation) mapped to the right plan tier (Foundation, Enterprise, or Guardian).
Behind the scenes, LaunchDarkly pricing is built around how you actually run in production: how many unique users you evaluate with flags, how many services/environments you connect, and whether you need experimentation and observability baked into the same runtime control plane.
Here’s how the process typically breaks down:
-
Initial Request (Contact Sales):
You start from the LaunchDarkly pricing page or “Contact Sales” form, indicating interest in Enterprise. This is where you define basic company details (size, industry, existing tooling) and note that you need Enterprise-level capabilities. -
Usage & Architecture Discovery:
A Sales or Solutions team member will walk through your architecture and usage patterns: MAU, number of services and replicas, environments (prod / staging / test), and whether you need experimentation and observability. These details drive the entitlement sizing, not a generic “per-seat” estimate. -
Plan & Entitlement Proposal:
Based on those inputs, you’ll receive a proposal that bundles:- Monthly active users (MAU)
- Service connections
- Optional Experimentation MAU
- Optional Observability usage
Plus the plan tier (Enterprise or Guardian) and any governance or compliance add‑ons you need.
Features & Benefits Breakdown
When you request LaunchDarkly Enterprise pricing with clear usage data, you’re not just getting a number—you’re defining how much control surface you can safely run in production.
| Core Feature | What It Does | Primary Benefit |
|---|---|---|
| MAU-based Entitlements | Allocates a pool of monthly active users (contexts) you can evaluate | Predictable cost as your user base grows while keeping flags available at scale |
| Service Connections | Counts microservices, replicas, and environments connected to LaunchDarkly | Aligns pricing to your actual architecture (not seats), matching runtime usage |
| Experimentation MAU | Sets how many users can be targeted in experiments each month | Enables statistically rigorous tests without separate tooling or workflow silos |
| Observability Entitlements | Includes logs/traces and SDK-powered monitoring for releases | Gives you error/performance visibility tied directly to feature flags |
| Plan Tiers (Foundation / Enterprise / Guardian) | Maps capabilities (governance, auto-rollback, policies) to your risk profile | Ensures you get the right controls for compliance, approvals, and guarded releases |
What Info They Need (And Why It Matters)
Think of the Enterprise pricing request as a sizing exercise: you’re giving LaunchDarkly enough signal to match entitlements to the way you ship and operate software.
1. Monthly Active Users (MAU)
What LaunchDarkly means by MAU
- MAU is the number of unique monthly active contexts evaluated by LaunchDarkly—typically user contexts, but it can also include org, account, or device contexts.
- Practically: any unique entity you pass into the SDK when evaluating a feature flag counts towards MAU.
What you should bring
- Your estimated unique monthly users that will encounter flags:
- Web users
- Mobile app users
- API consumers, if you model them as contexts
- If you have different products/teams, a rough split per product can help, but isn’t required for a first pass.
Why it matters for pricing
- For self‑serve and Foundation, a reference rate is:
- $10/mo per 1K client-side MAU (public info, subject to change)
- In Enterprise, these numbers become a committed entitlement block instead of pure “metered overage.”
- If you vastly underestimate MAU, you can:
- Hit your entitlements early
- Trigger overage billing, or
- In extreme cases, get moved into read-only mode when limits are continuously exceeded.
Coming prepared with realistic MAU estimates helps avoid those surprises.
2. Service Connections (Microservices, Replicas, Environments)
What a service connection is
From LaunchDarkly’s docs:
Service connections are the number of microservices, replicas, and environments connected to LaunchDarkly for 1 month.
In practice, this means:
- Each microservice or application instance that connects via SDK
- Counted across environments (prod, staging, dev, etc.)
- Includes replicas when they connect independently
What you should bring
- Number of distinct services you plan to integrate:
- Backend microservices
- Frontend apps (e.g., web SPA, admin console)
- Mobile apps / edge functions where SDKs will run
- For each, a rough idea of:
- Environments (e.g.,
production,staging,qa,dev) - Scale / replicas if relevant (especially if each replica connects independently)
- Environments (e.g.,
Why it matters for pricing
- Reference point from public pricing:
- $12/mo per service connection
- Enterprise plans bundle a defined number of service connections into your contract.
- If you’re adopting feature flags pervasively (which you should), this is the lever that aligns pricing to the actual runtime footprint of your system—not seat counts or abstract “projects.”
3. Environments
Environments affect how many service connections you’ll need and how governance/policies should be set up.
What you should bring
- Which environments you use today (for each service):
- Production
- Staging / pre‑prod
- QA / UAT
- Developer / ephemeral environments
- Whether you expect to:
- Spin up many temporary environments (e.g., per‑branch preview)
- Operate multiple prod regions (multi‑region or multi‑tenant architectures)
Why it matters for pricing and plan tier
- More environments typically mean:
- More service connections
- More need for release pipelines, policies, approvals, and audit logs
- If you run complex environment topologies, you’re more likely to benefit from:
- Enterprise or Guardian plans with stronger governance
- Automated rollback capabilities and consistent policies across environments
4. Experimentation MAU (Optional, but Highly Recommended)
If you want to run A/B tests on top of feature flags:
What Experimentation MAU is
- The number of users available to be targeted in experiments each month.
- Separate from base MAU, because not every user needs to be part of an experiment.
What you should bring
- How many users you expect to:
- Be eligible for experiments in a given month
- Need to reach for meaningful A/B differences (e.g., 50K, 500K, 5M)
- Whether experiments are:
- Product-led (growth, onboarding, pricing)
- Reliability-focused (performance impact of new features)
- AI behavior tests (different prompts/models via AI Configs)
Why it matters for pricing
- Public reference: $3/mo per 1K Experimentation MAU.
- Setting a realistic Experimentation MAU pool lets you:
- Run rigorous tests with LaunchDarkly’s Bayesian engine
- Avoid hitting experiment‑specific limits mid‑rollout
- Keep experimentation integrated into your normal feature flag workflow
5. Observability Usage (Logs, Traces, Metrics)
LaunchDarkly’s observability brings error, performance, and session‑level signal into the same plane as your feature flags.
What you should bring
- Rough telemetry volume today:
- Logs per day / month
- Trace or span volume
- The observability tools you use (so the team can advise on integrations)
Why it matters for pricing
- Plans can include entitlements like “10M Logs and Traces” with options to scale up.
- This determines how much data you can push into LaunchDarkly to:
- Power guarded releases (performance thresholds, auto‑rollback)
- Correlate errors and latency to specific flags and experiments
Ideal Use Cases
-
Best for organizations standardizing on feature flags across many teams:
Because Enterprise pricing is aligned to MAU and service connections, it scales as you roll flags out across dozens or hundreds of services without forcing per‑team contract renegotiations. -
Best for teams tying releases, experimentation, and observability together:
Because a single Enterprise contract can bundle feature flags, Experimentation MAU, and observability entitlements into one runtime control plane—so product, engineering, and data teams operate on the same surface.
Limitations & Considerations
-
Estimates, not precision, are expected—but underestimation has consequences:
You don’t need exact MAU or service counts down to the last user or replica. But if you drastically under‑estimate, your self‑serve plan can hit entitlements and move into read‑only mode after repeated overages. Give yourself headroom. -
Feature availability varies by plan tier:
Some capabilities—like advanced policies, compliance features, or Guardian‑style automated rollbacks—are only available on specific plans. If you have strict governance or regulatory requirements, flag that early in the pricing conversation.
Pricing & Plans
LaunchDarkly offers plan tiers like Foundation, Enterprise, and Guardian. Each can include monthly entitlements for:
- MAU (monthly active contexts)
- Service connections
- Observability usage (logs/traces)
- Experimentation MAU
Self‑serve public references give you a rough anchor:
- $12/mo per service connection
- $10/mo per 1K client-side MAU
- $3/mo per 1K Experimentation MAU
- Plus observability entitlements like “10M Logs and Traces” on certain plans
In Enterprise, those units are typically packaged as committed entitlements rather than purely pay‑as‑you‑go.
Examples of how plans might map to needs:
- Foundation: Best for growing teams needing feature management and experimentation on a limited number of services and environments, with predictable MAU and moderate observability volume.
- Enterprise / Guardian: Best for larger organizations with many microservices, stricter governance, or high‑risk releases needing automated rollback, advanced policies, approvals, and higher observability/experimentation entitlements.
Exact pricing requires a conversation with Sales because it depends on your specific scale, geography, and compliance needs.
Frequently Asked Questions
How do we actually request LaunchDarkly Enterprise pricing?
Short Answer: Use the “Contact Sales” or pricing form on launchdarkly.com and indicate you’re interested in Enterprise or higher-tier plans.
Details:
When you submit the form, include:
- Your estimated MAU (users/contexts evaluated per month)
- The number of services/replicas/environments you plan to connect
- Whether you need Experimentation and Observability entitlements
- Any compliance requirements (SOC 2, HIPAA, etc.)
A Sales or Solutions Engineer will follow up to clarify architecture, discuss how you want to standardize feature flag usage, and translate that into a concrete proposal.
What happens if we exceed our MAU or service entitlements?
Short Answer: You’ll be billed for usage beyond your entitlements, and if overages continue on some self‑serve plans, your account can move into read‑only mode.
Details:
For self‑serve and certain Foundation plans:
- You’re billed at the beginning of each month for usage exceeding your prior month’s entitlements.
- LaunchDarkly will:
- Warn you when you approach your entitlements
- Notify you again if you exceed them
- If you continue to exceed entitlements without adjusting your plan, your account may convert to read‑only mode, limiting changes until usage and contract are aligned.
Enterprise contracts are designed to minimize this friction by sizing entitlements to your realistic growth curve and revisiting them as your adoption increases.
Summary
Requesting LaunchDarkly Enterprise pricing is less about filling in a generic form and more about mapping the platform to how you actually ship: how many users you evaluate, how many services and environments you run, and whether you want experimentation and observability integrated into the same runtime control plane.
If you show up with three things—realistic MAU, a list of services/environments, and your appetite for experimentation + observability—you’ll get a quote that matches your architecture instead of a “per-seat” guess. That’s what keeps feature flags, AI Configs, and guarded releases safe and predictable at scale.