Skip to main content

Official SDKs

CODITECT provides official SDKs for popular programming languages.

Available SDKs​

LanguagePackageVersionInstall
Pythoncoditect1.0.0pip install coditect
JavaScript@coditect/sdk1.0.0npm install @coditect/sdk
Gocoditect-go1.0.0go get github.com/coditect-ai/coditect-go

Python SDK​

Installation​

pip install coditect

Quick Start​

from coditect import Client

# Initialize with API key
client = Client(api_key="cdt_live_xxx...")

# Or use environment variable
# export CODITECT_API_KEY=cdt_live_xxx...
client = Client()

# Get current user
user = client.auth.me()
print(f"Hello, {user.name}!")

# List projects
projects = client.projects.list()
for project in projects:
    print(f"- {project.name}")

License Management​

# Acquire a license seat
session = client.licenses.acquire(
    license_key="CODI-XXXX-XXXX-XXXX",
    hardware_id=client.get_hardware_id()
)

# Automatic heartbeat in background
client.licenses.start_heartbeat(session.session_id)

# ... your code here ...

# Release when done
client.licenses.release(session.session_id)

Context Manager​

# Automatic acquire/release
with client.licenses.session("CODI-XXXX-XXXX-XXXX") as session:
    # Session acquired, heartbeat running
    print(f"Session: {session.session_id}")
    # ... your code ...
# Automatically released on exit

Async Support​

import asyncio
from coditect import AsyncClient

async def main():
    client = AsyncClient(api_key="cdt_live_xxx...")

    # Async operations
    user = await client.auth.me()
    projects = await client.projects.list()

    # Concurrent requests
    results = await asyncio.gather(
        client.projects.get("proj_1"),
        client.projects.get("proj_2"),
        client.projects.get("proj_3"),
    )

asyncio.run(main())

Error Handling​

from coditect.exceptions import (
    CoditectError,
    AuthenticationError,
    RateLimitError,
    LicenseError,
)

try:
    session = client.licenses.acquire(...)
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
except LicenseError as e:
    if e.code == "no_seats_available":
        print("All seats in use")
except CoditectError as e:
    print(f"Error: {e.message}")

JavaScript SDK​

Installation​

npm install @coditect/sdk
# or
yarn add @coditect/sdk

Quick Start​

import { CoditectClient } from '@coditect/sdk';

// Initialize
const client = new CoditectClient({
  apiKey: 'cdt_live_xxx...'
});

// Or use environment variable
// CODITECT_API_KEY=cdt_live_xxx...
const client = new CoditectClient();

// Get current user
const user = await client.auth.me();
console.log(`Hello, ${user.name}!`);

// List projects
const projects = await client.projects.list();
projects.forEach(p => console.log(`- ${p.name}`));

TypeScript Support​

Full TypeScript support with exported types:

import { CoditectClient, Project, User, LicenseSession } from '@coditect/sdk';

const client = new CoditectClient({ apiKey: 'cdt_live_xxx...' });

async function main(): Promise<void> {
  const user: User = await client.auth.me();

  const projects: Project[] = await client.projects.list({
    limit: 10,
    status: 'active'
  });

  const session: LicenseSession = await client.licenses.acquire({
    licenseKey: 'CODI-XXXX-XXXX-XXXX',
    hardwareId: await client.getHardwareId()
  });
}

License Management​

// Acquire session
const session = await client.licenses.acquire({
  licenseKey: 'CODI-XXXX-XXXX-XXXX',
  hardwareId: await client.getHardwareId()
});

// Heartbeat is automatic with SDK

// Release on exit
process.on('SIGINT', async () => {
  await client.licenses.release(session.sessionId);
  process.exit();
});

Error Handling​

import {
  CoditectError,
  AuthenticationError,
  RateLimitError,
  LicenseError
} from '@coditect/sdk';

try {
  const session = await client.licenses.acquire({...});
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key');
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limited. Retry after ${error.retryAfter}s`);
  } else if (error instanceof LicenseError) {
    if (error.code === 'no_seats_available') {
      console.error('All seats in use');
    }
  } else if (error instanceof CoditectError) {
    console.error(`Error: ${error.message}`);
  }
}

Browser Usage​

<script type="module">
  import { CoditectClient } from 'https://cdn.coditect.ai/sdk/latest/index.esm.js';

  const client = new CoditectClient({
    apiKey: 'cdt_live_xxx...'
  });

  // Use client...
</script>

Go SDK​

Installation​

go get github.com/coditect-ai/coditect-go

Quick Start​

package main

import (
    "context"
    "fmt"
    "log"

    coditect "github.com/coditect-ai/coditect-go"
)

func main() {
    ctx := context.Background()

    // Initialize client
    client, err := coditect.NewClient(
        coditect.WithAPIKey("cdt_live_xxx..."),
    )
    if err != nil {
        log.Fatal(err)
    }

    // Get current user
    user, err := client.Auth.Me(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Hello, %s!\n", user.Name)

    // List projects
    projects, err := client.Projects.List(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    for _, p := range projects {
        fmt.Printf("- %s\n", p.Name)
    }
}

License Management​

// Acquire session
session, err := client.Licenses.Acquire(ctx, &coditect.AcquireParams{
    LicenseKey: "CODI-XXXX-XXXX-XXXX",
    HardwareID: client.GetHardwareID(),
})
if err != nil {
    log.Fatal(err)
}

// Start heartbeat goroutine
stopHeartbeat := client.Licenses.StartHeartbeat(ctx, session.SessionID)

// ... your code ...

// Stop heartbeat and release
stopHeartbeat()
err = client.Licenses.Release(ctx, session.SessionID)

Error Handling​

import "github.com/coditect-ai/coditect-go/errors"

session, err := client.Licenses.Acquire(ctx, params)
if err != nil {
    var authErr *errors.AuthenticationError
    var rateErr *errors.RateLimitError
    var licErr *errors.LicenseError

    switch {
    case errors.As(err, &authErr):
        log.Println("Invalid API key")
    case errors.As(err, &rateErr):
        log.Printf("Rate limited. Retry after %ds\n", rateErr.RetryAfter)
    case errors.As(err, &licErr):
        if licErr.Code == "no_seats_available" {
            log.Println("All seats in use")
        }
    default:
        log.Printf("Error: %v\n", err)
    }
}

SDK Features​

All SDKs Include​

FeaturePythonJavaScriptGo
Authentication✅✅✅
License Management✅✅✅
Auto Heartbeat✅✅✅
Project Management✅✅✅
Subscriptions✅✅✅
Webhooks✅✅✅
Rate Limit Handling✅✅✅
Retry Logic✅✅✅
TypeScript TypesN/A✅N/A
Async Support✅✅✅

Hardware ID Generation​

All SDKs include hardware fingerprinting:

# Python
hardware_id = client.get_hardware_id()

# JavaScript
const hardwareId = await client.getHardwareId();

// Go
hardwareID := client.GetHardwareID()

Hardware ID is based on:

  • CPU ID
  • MAC address
  • Disk serial
  • Motherboard ID

Community SDKs​

Community-maintained SDKs (not officially supported):

LanguagePackageAuthor
Rubycoditect-ruby@contributor
PHPcoditect/php-sdk@contributor
Rustcoditect-rs@contributor
Javacoditect-java@contributor
Community SDKs

Community SDKs are not officially maintained. Use at your own risk and check for updates regularly.

Contributing​

Want to contribute to our SDKs?

  1. Fork the repository
  2. Make your changes
  3. Add tests
  4. Submit pull request

See contributing guidelines in each SDK repository.