npm install @tenlyr/sdk
# or
yarn add @tenlyr/sdk
# or
pnpm add @tenlyr/sdk

import { Tenlyr } from '@tenlyr/sdk';

const tos = new Tenlyr({
  apiKey:     process.env.TENLYR_ADMIN_KEY, // required
  baseUrl:    'https://api.tenlyr.app',   // default
  timeout:    10_000,                         // ms, default 10 000
  retries:    3,                              // 5xx retries, default 3
  retryDelay: 200,                           // initial back-off ms
});

curl https://api.tenlyr.app/api/v1/tenants/dashboard \
  -H "Authorization: Bearer tenlyr_live_tf_..." \
  -H "User-Agent: tenlyr-sdk/1.0.0"

const { tenant, apiKey } = await tenlyr.tenants.create({
  name:       'Acme Corp',         // required
  ownerEmail: '[email protected]',      // required, must be unique
  plan:       'growth',             // optional, defaults to 'starter'
  region:     'us-east-1',          // optional, defaults to 'us-east-1'
});

console.log(tenant.id);   // "51fad484-7f82-4c97-..."
console.log(apiKey);      // "tenlyr_live_abc123..." - store this immediately

import { Tenlyr, ConflictError } from '@tenlyr/sdk';

try {
  const result = await tenlyr.tenants.create({ name, ownerEmail, plan });
} catch (err) {
  if (err instanceof ConflictError) {
    // Tenant already exists - fetch existing instead
    const { data } = await tenlyr.tenants.list();
    return data.find(t => t.ownerEmail === ownerEmail);
  }
  throw err;
}

// middleware/track-usage.ts
export function trackUsage(tenlyr: Tenlyr) {
  return async (req, res, next) => {
    res.on('finish', () => {
      if (req.tenantApiKey && res.statusCode < 500) {
        tenlyr.usage.track({
          tenantKey: req.tenantApiKey,
          metric: 'api_call',
          value: 1,
          endpoint: req.path,
        }).catch(console.error); // fire-and-forget
      }
    });
    next();
  };
}

const metrics = awaittenlyr.usage.metrics(tenantApiKey);

if (metrics.apiCalls >= planLimit * 0.8) {
  // Warn the user at 80%
  await notifyUser('Approaching API call limit');
}

if (metrics.apiCalls >= planLimit) {
  return res.status(429).json({ error: 'Plan limit reached' });
}

const { url } = awaittenlyr.billing.portalUrl(tenantApiKey);
res.redirect(url);

// Start migration - returns immediately, runs async
const migration = awaittenlyr.isolation.migrate(tenantId, {
  targetLevel: 'dedicated_schema',
});

console.log(migration.status); // 'pending' → transitions to 'in_progress' immediately

// Poll until done (throws on failure or timeout)
const completed = awaittenlyr.isolation.waitForMigration(migration.id, {
  pollIntervalMs: 500,
  timeoutMs:      600_000, // 10 min max
});

console.log(completed.status);  // 'completed'
console.log(completed.toLevel);  // 'dedicated_schema'

// Cap to 60 requests per minute
awaittenlyr.health.throttle(tenantId, 60);

// Remove throttle when issue is resolved
awaittenlyr.health.removeThrottle(tenantId);

tenlyr.tenants.create({ name, ownerEmail, plan?, region? })  // → { tenant, apiKey }
tenlyr.tenants.list({ limit?, cursor? })                       // → { data: Tenant[], nextCursor: string | null }
tenlyr.tenants.get(id)                                       // → Tenant
tenlyr.tenants.health()                                      // → DashboardTenant[]
tenlyr.tenants.update(id, { name?, region? })                // → Tenant
tenlyr.tenants.suspend(id, reason?)                          // → Tenant
tenlyr.tenants.reactivate(id)                                // → Tenant
tenlyr.tenants.terminate(id)                                 // → Tenant
tenlyr.tenants.rotateApiKey(id)                             // → { tenant, apiKey }
tenlyr.tenants.changePlan(id, plan)                         // → Tenant
tenlyr.tenants.delete(id)                                   // → void

tenlyr.usage.track({ tenantKey, metric, value, endpoint? })      // → UsageEvent
tenlyr.usage.metrics(tenantKey)                           // → TenantUsageMetric
tenlyr.usage.summary(tenantKey)                           // → UsageSummary
tenlyr.usage.events(tenantKey, limit?)                    // → UsageEvent[]

tenlyr.health.overview()                                 // → HealthOverview
tenlyr.health.list()                                     // → TenantHealth[]
tenlyr.health.get(tenantId)                              // → TenantHealth
tenlyr.health.throttle(tenantId, limitRpm)              // → TenantHealth
tenlyr.health.removeThrottle(tenantId)                  // → TenantHealth

tenlyr.isolation.migrate(tenantId, { targetLevel })     // → IsolationMigration
tenlyr.isolation.getMigration(id)                       // → IsolationMigration
tenlyr.isolation.migrations(tenantKey)                   // → IsolationMigration[]
tenlyr.isolation.waitForMigration(id, options?)          // → IsolationMigration

tenlyr.billing.get(tenantKey)                            // → TenantBilling
tenlyr.billing.portalUrl(tenantKey)                      // → { url: string }

tenlyr.alerts.list(key?)                                // → Alert[]
tenlyr.alerts.unresolved(key?)                          // → Alert[]
tenlyr.alerts.resolve(alertId)                          // → Alert
tenlyr.alerts.resolveAll(key?)                          // → { resolved: number }

import {
  AuthenticationError, PermissionError, NotFoundError,
  ConflictError, InvalidRequestError, RateLimitError,
  TenlyrError, TenlyrTimeoutError, TenlyrNetworkError,
} from '@tenlyr/sdk';

try {
  await tenlyr.tenants.create({ name, ownerEmail, plan });
} catch (err) {
  if (err instanceof ConflictError)       console.error('Email already exists');
  else if (err instanceof RateLimitError)   await sleep((err.retryAfter ?? 60) * 1000);
  else if (err instanceof TenlyrError)       console.error(err.statusCode, err.body);
  else throw err;
}

pip install tenlyr  # not yet available

import tenlyr

client = tenlyr.Tenlyr(
    api_key="tenlyr_live_tf_...",
    base_url="https://api.tenlyr.app",  # optional
    timeout=10.0,                        # seconds
)

import asyncio

async def main():
    # Provision a new tenant
    result = await client.tenants.create(
        name="Acme Corp",
        owner_email="[email protected]",
        plan="growth",
    )
    tenant, api_key = result.tenant, result.api_key

    # Track usage
    await client.usage.track(
        tenant_key=api_key,
        metric="api_call",
        value=1,
    )

    # Dashboard
    dashboard = await client.tenants.health()

asyncio.run(main())

go get github.com/tenlyr/tenlyr-go  // not yet available

import tenlyr "github.com/tenlyr/tenlyr-go"

client := tenlyr.New(tenlyr.Config{
    APIKey:  os.Getenv("TENLYR_ADMIN_KEY"),
    Timeout: 10 * time.Second,
})

ctx := context.Background()

// Provision
result, err := client.Provision(ctx, tenlyr.ProvisionRequest{
    Name:       "Acme Corp",
    OwnerEmail: "[email protected]",
    Plan:       "growth",
})
if err != nil { log.Fatal(err) }

// Track usage
err = client.Usage.Track(ctx, tenlyr.TrackRequest{
    Metric:       "api_call",
    Value:        1,
    TenantAPIKey: result.APIKey,
})

{
  "id": "evt_01HZ...",
  "type": "tenant.provisioned",
  "createdAt": "2026-03-14T10:00:00.000Z",
  "data": { /* event-specific payload */ }
}

import * as crypto from 'crypto';

function verifySignature(
  payload: Buffer,
  signature: string,
  secret: string
): boolean {
  const parts = signature.split(',')
    .reduce((acc, part) => {
      const [k, v] = part.split('=');
      acc[k] = v; return acc;
    }, {} as Record<string, string>);

  const expected = crypto
    .createHmac('sha256', secret)
    .update(`${parts['t']}.${payload.toString()}`)
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(parts['v1']),
    Buffer.from(expected)
  );
}

{
  "type": "tenant.provisioned",
  "data": {
    "tenantId": "51fad484-7f82-4c97-a3e1-b0c29d4f8201",
    "name": "Acme Corp",
    "plan": "growth",
    "region": "us-east-1"
  }
}

{
  "type": "health.critical",
  "data": {
    "tenantId": "51fad484-...",
    "errorRate": 12.4,
    "requestRate": 340,
    "slaRisk": true
  }
}

{
  "type": "isolation.migration_completed",
  "data": {
    "migrationId": "mig-uuid",
    "tenantId": "51fad484-...",
    "fromLevel": "shared_schema",
    "toLevel": "dedicated_schema"
  }
}