INTEGRATIONS

Your stack. Governed.

Arbitex sits between your applications and every AI provider you use. One enforcement point. No new SDKs. No refactoring. Connect your identity provider, observability stack, and developer toolchain — governance applies to everything.

Book a DemoTalk to Us
9 providers + BYOE

AI Model Providers

Route requests to any major provider through a single OpenAI-compatible API. Switch models without changing your code.

4 protocols

Identity & Access

Connect your existing identity infrastructure. Arbitex enforces authentication and authorization at the gateway — not the application layer.

7 SIEM + OTel

Visibility & Compliance

Export telemetry to the tools your team already uses. Every request produces structured, auditable data.

2 tools

Developer Tools

Arbitex integrates into every stage of the development lifecycle — from local development to production infrastructure.

OAuth 2.0

Machine-to-Machine Access

Authenticate CI/CD pipelines and automation agents using OAuth client credentials — governed by the same policy engine as interactive sessions.

5 platforms

Infrastructure & Deployment

Deploy Arbitex in your existing infrastructure. Helm charts, Docker Compose, and managed Kubernetes on Azure, Google Cloud, or AWS — no custom tooling required.

AI Model Providers

One-line integration. 9 providers. Any model.

Arbitex exposes an OpenAI-compatible API. Point your existing SDK at the gateway. No new libraries. No refactoring.

Python / any OpenAI-compatible SDK
base_url = "https://api.arbitex.ai/v1"

That is the entire integration. Every request now flows through the governance pipeline — routing, DLP inspection, policy enforcement, and audit logging applied automatically. Existing code, existing SDKs, new governance.

Multi-Provider Routing

Send requests to any supported provider. Arbitex handles authentication, rate limiting, and failover. Switch from OpenAI to Azure OpenAI or AWS Bedrock without touching application code. Route different request types to different providers based on policy.

  • OpenAI
  • Anthropic
  • Google Gemini
  • Microsoft Azure OpenAI
  • AWS Bedrock
  • Ollama
  • Mistral
  • Cohere
  • Groq
  • Bring Your Own Endpoint (self-hosted models)

Model Governance

Policy enforcement is model-agnostic. DLP inspection, content filtering, and audit logging apply to every provider — not just the one you started with. Add a provider to your routing policy and governance follows automatically.

Switch providers. Governance stays in place. No policy rewrites.

Identity & Access

Your identity provider. Arbitex enforces it.

Connect your existing identity infrastructure. Arbitex enforces authentication and authorization at the gateway — not the application layer.

SAML 2.0

Arbitex operates as a SAML 2.0 Service Provider with Single Logout support. Verified integrations with Okta, Azure AD, and Google Workspace. Group membership from your IdP maps directly to RBAC roles inside Arbitex.

SCIM 2.0

Automate user provisioning and deprovisioning. When a user is offboarded in your identity provider, access to Arbitex is revoked automatically. Group changes sync to RBAC roles (depends on IdP sync frequency).

OIDC

OpenID Connect single sign-on. Complements SAML for environments running both protocols.

WebAuthn / FIDO2

Passwordless authentication for human access. Hardware security key support — YubiKey, FIDO2 authenticators. Phishing-resistant by design.

MFA

TOTP-based multi-factor authentication with backup codes. Enforced for all human access to production infrastructure. No exceptions.

Verified Identity Providers

Okta

SAML 2.0 SSO with group-to-role mapping. SCIM 2.0 provisioning for automated user lifecycle management. Attribute statements map Okta groups directly to Arbitex RBAC roles.

Setup guide →

Microsoft Entra ID (Azure AD)

SAML 2.0 SSO with Entra ID group claims. SCIM 2.0 provisioning via Entra ID enterprise application. OpenID Connect single sign-on for environments preferring OIDC.

Setup guide →

Google Workspace

SAML 2.0 SSO with Google Workspace organizational unit mapping. Google Sign-In (OIDC) supported for consumer-facing deployments. Group membership syncs to Arbitex RBAC roles.

Setup guide →
Visibility & Compliance

Every request. Structured data. Your existing stack.

Every request produces a structured trace: model, provider, latency, token counts, policy decisions, DLP findings. Export to your existing observability backend.

OpenTelemetry Export

Export to any OpenTelemetry-compatible backend. Your existing observability stack receives Arbitex data alongside application telemetry. Model, provider, latency, token counts, policy decisions, DLP findings — all in one trace. Supports OTLP over gRPC and HTTP.

Grafana Dashboards

Pre-built Grafana dashboard definitions for request volume, latency distribution, DLP trigger rates, policy violations, and cost by provider. Deploy to your existing Grafana instance. Includes Prometheus alert rule definitions for health, quota, and compliance thresholds.

SIEM Integration

Direct connectors to Splunk HEC, Microsoft Sentinel, Elastic SIEM, Datadog, Sumo Logic, IBM QRadar, and Cortex XSIAM. Every governance event — request, policy decision, DLP finding, block action — produces a structured JSON log entry routed to your existing SOC tooling.

Hybrid Outpost deployments support a direct SIEM sink — forward audit events natively from within your environment, without routing through the cloud data plane.

Webhook Delivery

Configure webhooks for real-time event delivery to any HTTP endpoint. DLP findings, policy violations, budget threshold alerts, and user lifecycle events are pushed as structured JSON payloads with cryptographic signature verification. Retry with exponential backoff. Delivery tracking in the admin portal.

SOC 2 Report Generation

Generate compliance summary reports on demand. Structured output maps gateway activity to SOC 2 control categories. Share with auditors directly. No manual log extraction.

Signed Audit Exports

Export audit logs with cryptographic signatures for external verification. Chain of custody is preserved. Exports are tamper-evident. Suitable for regulatory submissions and third-party audits.

Budget Enforcement

Set monthly spending caps and request quotas per user, team, or organization. Hybrid Outpost enforces budget limits locally — requests are blocked at the data plane when caps are reached, with configurable warning thresholds at 80% and hard stops at 100%. Budget status is visible in real time.

Deploy Readiness Controls

Hybrid Outpost includes GeoIP-based access controls — restrict AI model access to requests originating from approved geographic regions or block traffic from high-risk jurisdictions before it reaches the gateway. Software components ship with cryptographic signatures and verified integrity checksums, enabling air-gapped environments to validate update authenticity without contacting external package registries.

Developer Tools

Integrate once. Govern everywhere.

Arbitex integrates into every stage of the development lifecycle — from local development to production infrastructure.

Python

from openai import OpenAI

client = OpenAI(
    api_key="your-arbitex-key",
    base_url="https://api.arbitex.ai/v1"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize this contract."}]
)

Use any OpenAI-compatible SDK. Just change your base URL — no custom packages to install.

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ARBITEX_API_KEY,
  baseURL: "https://api.arbitex.ai/v1",
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Summarize this contract." }],
});

Same governance pipeline. Same audit trail. Works with any OpenAI-compatible library.

Machine-to-Machine Access

Machine-to-Machine Authentication

CI/CD pipelines, automation agents, and backend services access the Arbitex API using the OAuth 2.0 client credentials grant. Every automated request passes through the same DLP inspection and policy enforcement as interactive sessions.

curl — get an access token

curl -X POST https://api.arbitex.ai/api/oauth/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=ci-pipeline-prod-a1b2c3" \
  -d "client_secret=YOUR_CLIENT_SECRET"

Python — client credentials flow

import requests

token_response = requests.post(
    "https://api.arbitex.ai/api/oauth/token",
    data={
        "grant_type": "client_credentials",
        "client_id": "ci-pipeline-prod-a1b2c3",
        "client_secret": "YOUR_CLIENT_SECRET",
    },
)
access_token = token_response.json()["access_token"]

# Use the token to call the Arbitex API
response = requests.post(
    "https://api.arbitex.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer {access_token}"},
    json={"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello"}]},
)

Token verification: M2M access tokens are RS256-signed JWTs. Verify tokens using the JWKS endpoint at https://api.arbitex.ai/.well-known/jwks.json — no shared secrets required. Learn more about RS256 signing →

Create and manage OAuth clients in Account > OAuth Clients in Arbitex Cloud. For the full integration guide, see the documentation.

Infrastructure & Deployment

Your infrastructure. Your rules.

Deploy Arbitex using the orchestration tools your team already uses. No proprietary agents or custom infrastructure required.

Kubernetes (Helm)

Production-ready Helm chart with configurable replicas, resource limits, ingress, and TLS. Supports horizontal pod autoscaling and rolling updates. Compatible with any CNCF-conformant Kubernetes cluster.

Docker Compose

Single-command deployment for development, staging, and small production environments. Includes the full Arbitex stack — gateway, PostgreSQL, Redis, and admin portal — in one compose file.

Azure AKS

Validated deployment on Azure Kubernetes Service with Azure-native integrations. Supports Azure Key Vault for secrets, Azure Monitor for telemetry, and Entra ID for authentication.

Google GKE

Validated deployment on Google Kubernetes Engine. Supports Workload Identity for IAM-based pod authentication, Cloud KMS for encryption key management, and Cloud Monitoring for telemetry.

Amazon EKS

Validated deployment on Amazon Elastic Kubernetes Service. Supports IAM Roles for Service Accounts (IRSA), AWS Secrets Manager for credential storage, and CloudWatch for observability.

Read the integration guides

Every model. Every tool. One governance layer.

Arbitex connects to the infrastructure you already run. No rip-and-replace. Can't find your integration? Contact us — we're adding new connectors regularly.

Book a DemoContact Us