Frequently Asked Questions

ToggleAI SDKs run feature flags evaluations entirely locally and in-memory. When your application boots, the SDK retrieves the compiled environment configuration payload from our edge CDN nodes.

By performing in-memory feature flag evaluation, subsequent checks resolve in under 1ms without making blocking network requests.

To learn how to implement feature flags in React, you can use our lightweight client-side SDK. First, install the package and wrap your root layout in the provider:

// App.tsx - feature flags typescript example
import { ToggleAIProvider } from "@toggleai/react"

export default function App() {
  return (
    <ToggleAIProvider clientKey="client_sdk_key" user={{ id: "usr_123" }}>
      <MyDashboard />
    </ToggleAIProvider>
  )
}

Then, use the custom Hook in your React components or utilize our typed helpers for robust feature flags typescript support:

import { useFeatureFlag } from "@toggleai/react"

function MyDashboard() {
  const isNewDashboard = useFeatureFlag("new-dashboard-v2")
  return isNewDashboard ? <NewDashboard /> : <LegacyDashboard />
}

Yes! For backend developers, our python feature flag sdk tutorial demonstrates how to fetch and evaluate flags locally to avoid any network overhead. You can implement feature flags python checks like so:

# install with: pip install toggleai
from toggleai import ToggleAIClient

# Initialize the client (fetches rules dynamically in background)
client = ToggleAIClient(api_key="ak_live_python_xxxxx")

# Evaluate feature flags python example
user_context = {"userId": "usr_789", "tier": "premium"}
if client.is_enabled("new-billing-engine", user_context):
    execute_new_flow()
else:
    execute_legacy_flow()

This architecture ensures backend flag checks take under 1ms because they are evaluated using local, in-memory configurations.

No. Individual evaluations do not trigger outbound HTTP connections. The SDK maintains a local cache of states and rules.

Evaluation telemetry is buffered in memory and flushed periodically in the background as batched payloads to our backend, preventing client-side main-thread blocking.

ToggleAI is built from the ground up as a unified feature management system. It combines boolean feature toggling with a powerful, developer-first remote config engine.

This allows developers to deploy flags for feature rollouts while also storing dynamic configurations (JSON, numbers, strings) that can be changed instantly in our cloud console and distributed to all active edge SDKs in milliseconds.

Implementing remote config flutter allows you to deliver dynamic, non-boolean values to mobile clients without redeploying to app stores.

To retrieve a flutter remote config key value, initialize the Flutter SDK and request the typed variable:

// Flutter/Dart remote config example
import 'package:toggleai_flutter/toggleai_flutter.dart';

final toggleAI = ToggleAI.instance;

// Retrieve remote config values instantly
String buttonColor = toggleAI.getString(
  'promo_button_hex', 
  defaultValue: '#39FF14'
);
double maxRetries = toggleAI.getDouble(
  'max_retries', 
  defaultValue: 3.0
);

Structured logging is the practice of serializing log events in a consistent, machine-readable format (like JSON) rather than plain text.

ToggleAI integrates structured logging directly with flag evaluations to map variant assignments to application errors or performance metrics. This allows our AI core to correlate specific code variations with application health telemetry.

To track flag evaluations without degrading application performance, you can use node structured logging coupled with a batched logging buffer typescript transport.

Our TypeScript and Node SDKs queue logging metadata in memory and flush them in batches, reducing the number of external HTTPS requests:

import { ToggleAI, InMemoryBuffer } from "@toggleai/node"

const client = new ToggleAI({
  apiKey: "ak_live_node_xxxxx",
  // Set up a custom batched logging buffer
  telemetryBuffer: new InMemoryBuffer({
    maxBatchSize: 100,
    flushIntervalMs: 5000, // Flush every 5 seconds
  })
})

In our multivariate ab testing developer guide, we recommend running experiments directly through feature flags by passing variant rules.

Instead of relying on heavy browser-side redirect scripts, ToggleAI encourages ab testing for developers at the code level, defining multiple variations (multivariate) and tracking results on the server or client side:

// Serve multivariate options locally
const landingPageVersion = client.getVariant(
  "pricing-layout-experiment",
  { userId: user.id }
)

switch (landingPageVersion) {
  case "variant_a": renderLayoutA(); break;
  case "variant_b": renderLayoutB(); break;
  default: renderControl();
}

ToggleAI provides a robust free allowance for every organization, with no credit card required. The limits include:

Remaining within these allocations keeps your billing exactly $0.00 forever.

If your organization requires additional resources, you can subscribe to the Pay-As-You-Go Plan for $9.99/month.

This subscription unlocks unlimited team seats, additional projects, and enables automatic metered overage billing based on exact usage.

Once subscribed, usage beyond your free allowances is billed dynamically at the end of your billing cycle:

• Evaluations: $0.01 per 15,000 evaluations
• Feature Flags: $0.02 per active flag / month
• Configurations: $0.01 per active config / month
• Environments: $0.01 per environment / month
• AI Suggestions: $0.01 per insight processed
• A/B Experiments: $0.15 per 10 active experiments
• Auto-Experiments: $0.10 per 5 converted experiments
• AI Error Fixes: $0.50 per 25 diagnostic suggestions

Yes. In the Organization Billing Dashboard, you can set custom spend threshold warnings and hard spend limits (USD).

If your accrued spend reaches the hard limit, further evaluations safely fall back to default configuration values locally to avoid downtime or invoice shocks.

Our background analyzer monitors aggregate flag performance and status changes.

It detects anomalous latency patterns, identifies stagnant flags (e.g., 100% rollout for over 30 days), and generates recommendations to clean up variables, reducing your edge payload sizes by up to 40%.

By tracking telemetry events (views, clicks, purchases) alongside flag variations, ToggleAI automatically calculates conversion shifts.

The engine handles cohort assignments, statistical validity criteria, and confidence checks (providing p-value metrics), dynamically flagging when a variant is statistically superior.

The model processes metadata exclusively, including evaluation counters, duration averages, and HTTP code feedback.

No personally identifiable information (PII), database structures, or proprietary code is uploaded or analyzed, ensuring strict data segregation and security compliance.