WSO2 is now Choreo LabsLearn more

Trusted AI Governance
Build

Create agents and AI apps with the tools and languages your teams already use.

Connect

Link agents securely to your APIs, data, models and business systems.

Run

Deploy, observe and operate agents and AI apps reliably at any scale.

Govern

Control identity, access, cost and policy for every agent in production.

Agent Management

Developer Platform

  • API Management Cloud

    Design, secure and publish APIs with governance and analytics built in.

    Sign Up Now
  • Integration Cloud

    Connect apps, data and AI agents with low-code and pro-code integration.

    Sign Up Now
  • Identity & Access Management Cloud

    Secure sign-in and access for customers, partners, workforce and agents.

    Sign Up Now
  • Agent Management Cloud

    Build, run and govern AI agents with full visibility and control.

    Sign Up Now
  • Developer Platform Cloud

    Ship cloud-native apps faster on an internal developer platform.

    Sign Up Now

Self-Hosted

Full control over your stack. Deploy directly to your own servers, bare metal, cloud, or Kubernetes environment. Your data never leaves your perimeter.

Product Downloads
Choreo Labs
AI Governance
Platform
Solutions
Resources

API-first integration for modern enterprises

Turn integration logic into discoverable, reusable, and governed APIs. Expose legacy systems, orchestrate multiple services, and deliver secure, composable digital capabilities across cloud, hybrid, and on-prem environments.

Point-to-point integration does not scale

Traditional integration is focused on connecting systems directly—application to application, database to database. While effective for isolated use cases, this approach creates tightly coupled architectures that are difficult to evolve.

As enterprises adopt microservices, SaaS platforms, digital channels, partner ecosystems, and AI agents, integration must become a standardized, governed capability layer.

Without exposing integrations as APIs, organizations face duplicated logic, inconsistent security policies, limited reuse, and slower innovation cycles.

APIs are the primary interface of the modern enterprise

APIs are now the primary interface for applications, partners, digital channels, and AI agents.

Turning integrations into managed APIs enables:

  1. Standardized governance

    Authentication, throttling, monitoring, lifecycle management, and policy enforcement become consistent across all integrations.

  2. Reusability and composability

    Integration flows become discoverable business capabilities instead of one-off project artifacts.

  3. Reduced architectural complexity

    Backend systems can evolve independently while maintaining stable API contracts.

  4. Faster innovation

    New channels, products, and AI-powered experiences can be delivered without rebuilding core integrations.

  5. API-led integration strategy

    Integration evolves from connectivity plumbing into a strategic capability layer.

Real-world integrations as APIs scenarios

Modernizing legacy systems

Continue leveraging legacy investments by exposing functionality as REST, GraphQL, or gRPC APIs without rewriting core systems.

AI agent consumption

Deliver stable, structured APIs that AI agents and GenAI applications can reliably invoke.

Composite services and backend-for-frontend (BFF) layers

Orchestrate multiple systems behind a single API contract to power mobile apps, web portals, and digital experiences.

Partner and ecosystem enablement

Provide secure, governed APIs for external partners and suppliers.

Cross-system orchestration

Combine transformation, connectors, events, and file integration into unified API-driven workflows.

Reference architecture

Why use Choreo for integrations as APIs

  • API-first by design

    Choreo Integrator is built around an API-first philosophy. Every integration can be designed, versioned, secured, and governed as a managed API from day one.

  • Support for all API styles

    Support for REST, SOAP, GraphQL, WebSocket, Async APIs, webhooks, and streaming enables modernization of legacy systems while supporting event-driven and real-time architectures.

  • Unified integration + API capabilities

    Integration logic and API exposure operate on a single platform, reducing architectural complexity and eliminating the need for disconnected tooling.

  • Low-code and pro-code development

    Unified low-code and pro-code development with 100% parity, powered by the Ballerina programming language.

  • Enterprise-grade runtime

    Execute APIs with high-performance mediation, transformation, clustering, retries, and distributed observability.

  • Deploy anywhere

    Run self-hosted on VMs or Kubernetes, in hybrid environments, or as a fully managed iPaaS, while maintaining architectural control.

Build once. Reuse everywhere.

Empower developers to design integration flows as reusable API contracts while enabling platform teams to enforce governance and consistency.

  • API-first specification support

    Design and expose integrations as structured API contracts from day one, ensuring consistent interfaces across teams.

  • Reusable integration components

    Build modular, shareable integration flows that can be reused across projects and teams to eliminate duplicated effort.

  • Centralized lifecycle management

    Manage integration versions, dependencies, and deployments from a single control plane with full governance visibility.

  • Built-in metrics, logs, and tracing

    Monitor integration health with end-to-end observability including OpenTelemetry support and real-time diagnostics.

  • AI-assisted development support

    Use the MI Copilot in VS Code to generate integration artifacts, validate syntax, and iterate on flows conversationally.

Turn integrations into digital capabilities

Design, expose, and manage integrations as reusable APIs that power applications, partners, and AI agents.

Self-hosted

Full control over your stack. Deploy directly to your own servers, bare metal, or a private cloud environment. Your data never leaves your perimeter.

  • Complete data sovereignty
  • Air-gapped environment support
  • Kubernetes, Docker, VM, or bare metal
  • Bring your own CI/CD pipeline

SaaS

Zero infrastructure to manage. Choreo Labs handles provisioning, upgrades, scaling, and availability. Get started in minutes.

  • Data plane anywhere you want
  • Centralized control and observability
  • Continuous updates, zero downtime
  • Multi-region availability