SDKs & Integration

Supported Platforms

SkillBoss works seamlessly with all major AI coding assistants:

Quick Start

One-command setup: Tell your agent set up skillboss.co/skill.md to auto-configure SkillBoss with 687+ APIs.

1. Download SkillBoss

Get your personalized skills pack from the Console:

# Download will give you: skillboss-skills.zip
unzip skillboss-skills.zip

2. Install in Your Tool

For Claude Code / Cursor / Windsurf:

# Copy to skills directory
cp -r skillboss-skills ~/.claude/skills/skillboss
# Or let AI install it for you - just attach the ZIP and say:
# "Help me install skillboss-skills.zip"

For OpenClaw:

npm install -g openclaw
openclaw install skillboss-skills.zip

3. Start Using

Just ask your AI to use SkillBoss services:

Generate a product demo video using Veo 3.1

Build a waiting list app with Stripe payments

Scrape 100 LinkedIn profiles from this company

Direct API Access

You can also call SkillBoss APIs directly:

Python

import requests

API_KEY = "your-skillboss-api-key"
BASE_URL = "https://api.skillboss.co/v1"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Generate an image
response = requests.post(
    f"{BASE_URL}/image/generate",
    json={
        "model": "dall-e-3",
        "prompt": "A futuristic cityscape",
        "size": "1024x1024"
    },
    headers=headers
)

result = response.json()
print(result["image_url"])

JavaScript/TypeScript

const SKILLBOSS_API_KEY = "your-skillboss-api-key"
const BASE_URL = "https://api.skillboss.co/v1"

async function generateImage(prompt) {
  const response = await fetch(`${BASE_URL}/image/generate`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${SKILLBOSS_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "dall-e-3",
      prompt: prompt,
      size: "1024x1024"
    })
  })

  const result = await response.json()
  return result.image_url
}

// Usage
const imageUrl = await generateImage("A futuristic cityscape")
console.log(imageUrl)

cURL

curl -X POST https://api.skillboss.co/v1/image/generate \
  -H "Authorization: Bearer your-skillboss-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "dall-e-3",
    "prompt": "A futuristic cityscape",
    "size": "1024x1024"
  }'

Framework Integration

LangChain

from langchain.llms import SkillBoss

llm = SkillBoss(
    api_key="your-skillboss-api-key",
    model="claude-4-sonnet"
)

response = llm("What is the capital of France?")
print(response)

Vercel AI SDK

import { SkillBoss } from '@skillboss/vercel-ai'

const skillboss = new SkillBoss({
  apiKey: process.env.SKILLBOSS_API_KEY
})

const response = await skillboss.chat.completions.create({
  model: 'gpt-5-2',
  messages: [{ role: 'user', content: 'Hello!' }]
})

OpenAI SDK (Compatible)

SkillBoss is compatible with OpenAI SDK:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="claude-4-sonnet",  # Use any SkillBoss model
    messages=[{"role": "user", "content": "Hello!"}]
)

Environment Variables

Store your API key securely:

Bash/Zsh

# Add to ~/.bashrc or ~/.zshrc
export SKILLBOSS_API_KEY="your-api-key-here"

.env File

SKILLBOSS_API_KEY=your-api-key-here
SKILLBOSS_BASE_URL=https://api.skillboss.co/v1

In Code

import os
from dotenv import load_dotenv

load_dotenv()
API_KEY = os.getenv("SKILLBOSS_API_KEY")

Advanced Usage

Streaming Responses

import requests

def stream_chat(prompt):
    response = requests.post(
        "https://api.skillboss.co/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "model": "claude-4-sonnet",
            "messages": [{"role": "user", "content": prompt}],
            "stream": True
        },
        stream=True
    )

    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))

stream_chat("Tell me a story")

Function Calling

const response = await fetch("https://api.skillboss.co/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "gpt-5-2",
    messages: [
      { role: "user", content: "What's the weather in San Francisco?" }
    ],
    functions: [
      {
        name: "get_weather",
        description: "Get the current weather",
        parameters: {
          type: "object",
          properties: {
            location: { type: "string" }
          }
        }
      }
    ]
  })
})

Batch Requests

# Generate multiple images at once
images = []
prompts = [
    "A sunset over mountains",
    "A cityscape at night",
    "A forest in autumn"
]

for prompt in prompts:
    response = requests.post(
        "https://api.skillboss.co/v1/image/generate",
        json={"model": "dall-e-3", "prompt": prompt},
        headers=headers
    )
    images.append(response.json()["image_url"])

Error Handling

Always handle errors gracefully:

try:
    response = requests.post(
        "https://api.skillboss.co/v1/chat/completions",
        json={"model": "claude-4-sonnet", "messages": [...]},
        headers=headers
    )
    response.raise_for_status()
    result = response.json()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 401:
        print("Invalid API key")
    elif e.response.status_code == 429:
        print("Rate limit exceeded")
    elif e.response.status_code == 402:
        print("Insufficient credits")
    else:
        print(f"Error: {e}")

Rate Limits

SkillBoss has generous rate limits:

• 100 requests per minute per API key
• 1000 requests per hour per API key
• 10000 requests per day per API key

If you exceed limits, you'll receive a 429 error. Implement exponential backoff:

import time

def call_with_retry(func, max_retries=3):
    for i in range(max_retries):
        try:
            return func()
        except RateLimitError:
            if i == max_retries - 1:
                raise
            time.sleep(2 ** i)  # Exponential backoff

WebSocket Support

For real-time applications:

const ws = new WebSocket(
  "wss://api.skillboss.co/v1/stream",
  ["Authorization", API_KEY]
)

ws.onmessage = (event) => {
  const data = JSON.parse(event.data)
  console.log(data)
}

ws.send(JSON.stringify({
  model: "claude-4-sonnet",
  messages: [{ role: "user", content: "Hello!" }]
}))

Next Steps