Developer Platform

Built for developers,
by developers

Simple HTTP integration, automatic context injection, and a built-in permission model. Get up and running in minutes.

Integration Flow

Three steps to connect your app

Define Your App

Create a JSON definition describing your application, routes, permissions, and navigation.

{

"id": "vendor/my-app"

}

Implement Your Handler

Build your HTTP endpoint. Auth is handled — your app receives enriched requests with full context.

func Handle(w, r) {

// auth already handled

}

Deploy & Register

Deploy your application and register it. Health monitoring and routing are automatic.

$ curl -X POST

/api/apps/register

Code Examples

See how it works

{
  "id": "acme/dashboard",
  "name": "Dashboard",
  "description": "Analytics dashboard for workspace metrics",
  "icon": "chart-bar",
  "uiMode": "full",
  "category": "analytics",
  "permissions": [
    {
      "key": "dashboard:read",
      "name": "View Dashboard",
      "description": "Access the analytics dashboard"
    },
    {
      "key": "dashboard:admin",
      "name": "Admin Dashboard",
      "description": "Configure dashboard settings"
    }
  ],
  "paths": [
    { "path": "/dashboard/*", "permissions": ["dashboard:read"] },
    { "path": "/admin/*", "permissions": ["dashboard:admin"] }
  ],
  "navigation": [
    { "title": "Dashboard", "path": "/dashboard", "icon": "chart-bar" },
    { "title": "Settings", "path": "/admin/settings", "icon": "cog" }
  ]
}

package main

import (
    "encoding/json"
    "net/http"
)

type Response struct {
    Status struct {
        Code    int    `json:"code"`
        Message string `json:"message"`
    } `json:"status"`
    Data interface{} `json:"data"`
}

func HandleDashboard(w http.ResponseWriter, r *http.Request) {
    // Authentication is already handled by Open Byte
    userID := r.Header.Get("X-Kx-Request-UserID")
    workspaceID := r.Header.Get("X-Kx-Request-WorkspaceID")
    traceID := r.Header.Get("X-Kx-Request-TraceID")

    // Check permissions from injected headers
    authHeader := r.Header.Get("X-Kx-Request-Authorization")

    // Your application logic here
    metrics := getWorkspaceMetrics(workspaceID, userID)

    resp := Response{}
    resp.Status.Code = 200
    resp.Status.Message = "OK"
    resp.Data = metrics

    w.Header().Set("Content-Type", "application/json")
    w.Header().Set("X-Trace-ID", traceID)
    json.NewEncoder(w).Encode(resp)
}

GET /dashboard/metrics HTTP/1.1
Host: acme-dashboard.internal:8080

X-Kx-Request-TraceID: 550e8400-e29b-41d4-a716-446655440000
X-Kx-Request-WorkspaceID: ws_7f3a2b1c-9d4e-4a8f-b2e1
X-Kx-Request-UserID: usr_9d4e8f2a-3b7c-4d1e-a5f6
X-Kx-Request-Authorization: [{"effect":"allow","action":"dashboard:read"}]
X-Kx-Request-Signature: sha256=a1b2c3d4e5f6789...
X-Kx-Request-Brands: brand_001,brand_002
X-Kx-Request-Departments: dept_engineering,dept_product
X-Kx-Request-Channels: channel_web,channel_api

Developer Tools

Built with developers in mind

Simple HTTP Integration

Register your app with a single HTTP call. No SDK required — any language or framework that speaks HTTP works out of the box.

Automatic Context Injection

Every request includes user identity, workspace context, permissions, and organizational data as standard HTTP headers.

Built-in Permission Model

Define permissions in your app registration. Open Byte enforces them at the proxy layer before requests reach your backend.

Request Signing

Verify request authenticity with SHA256 signatures. Every proxied request can be cryptographically verified by your backend.

Health Monitoring

Open Byte monitors your application's health automatically. Failed health checks are reported cluster-wide.

TypeScript + Go

Build your frontend with TypeScript and Lit web components. Build your backend in Go with the high-performance FastHTTP framework.

API Standard

Consistent response format

All API responses follow a standard envelope format. Consistent status codes, trace IDs for debugging, and structured data payloads.

Standard HTTP status codes in every response
Trace IDs for end-to-end request debugging
Structured JSON payloads with consistent schemas
Error responses with actionable messages

response.json

{
  "status": {
    "code": 200,
    "message": "OK"
  },
  "meta": {
    "traceID": "550e8400-e29b-41d4-a716-446655440000",
    "timestamp": "2026-02-21T10:30:00Z",
    "version": "1.0"
  },
  "data": {
    "workspaces": [
      {
        "id": "ws_7f3a2b1c",
        "name": "Acme Corp",
        "status": "active"
      }
    ]
  }
}

Ready to build?

Join the developer community and start building connected applications today.

Get Started View on GitHub

Built for developers,by developers