Replit + SkillBoss: 100+ AI Models for Cloud IDE

Why Replit + SkillBoss?

Replit is a cloud IDE where you can build and deploy apps instantly.

Problem: Building AI apps on Replit requires managing multiple API keys and providers.

Solution: SkillBoss gives you ONE API key for everything:

Quick Setup (2 Minutes)

Quick setup for AI agents: Tell your agent set up skillboss.co/skill.md to auto-configure everything.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["SKILLBOSS_API_KEY"],
    base_url="https://api.skillboss.co/v1"
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v3",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Python Templates

AI Chat App

# main.py
import os
from flask import Flask, request, jsonify
from openai import OpenAI

app = Flask(__name__)
client = OpenAI(
    api_key=os.environ["SKILLBOSS_API_KEY"],
    base_url="https://api.skillboss.co/v1"
)

@app.route("/chat", methods=["POST"])
def chat():
    message = request.json.get("message", "")
    response = client.chat.completions.create(
        model="deepseek/deepseek-v3",
        messages=[{"role": "user", "content": message}]
    )
    return jsonify({"reply": response.choices[0].message.content})

@app.route("/")
def home():
    return "AI Chat API is running!"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

Image Generation

import os
import requests

def generate_image(prompt):
    response = requests.post(
        "https://api.skillboss.co/v1/images/generations",
        headers={"Authorization": f"Bearer {os.environ['SKILLBOSS_API_KEY']}"},
        json={
            "prompt": prompt,
            "model": "flux/schnell",
            "size": "1024x1024"
        }
    )
    return response.json()["data"][0]["url"]

# Usage
image_url = generate_image("A futuristic city at sunset, cyberpunk style")
print(f"Generated: {image_url}")

Node.js Templates

AI Chat App

// index.js
import OpenAI from 'openai';
import express from 'express';

const app = express();
app.use(express.json());

const client = new OpenAI({
  apiKey: process.env.SKILLBOSS_API_KEY,
  baseURL: 'https://api.skillboss.co/v1'
});

app.post('/chat', async (req, res) => {
  const { message } = req.body;
  const response = await client.chat.completions.create({
    model: 'deepseek/deepseek-v3',
    messages: [{ role: 'user', content: message }]
  });
  res.json({ reply: response.choices[0].message.content });
});

app.listen(8080, () => console.log('Server running on port 8080'));

With Payments

import express from 'express';
import fetch from 'node-fetch';

const app = express();
app.use(express.json());

app.post('/checkout', async (req, res) => {
  const { amount } = req.body;

  const response = await fetch('https://api.skillboss.co/v1/payments/checkout', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.SKILLBOSS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      amount: amount, // in cents
      currency: 'usd',
      success_url: 'https://your-replit.repl.co/success',
      cancel_url: 'https://your-replit.repl.co/cancel'
    })
  });

  const data = await response.json();
  res.json({ checkout_url: data.url });
});

app.listen(8080);

Recommended Models

Full-Stack Template: AI SaaS

Build a complete SaaS with AI, payments, and email:

# app.py - Complete AI SaaS
import os
from flask import Flask, request, jsonify, redirect
from openai import OpenAI
import requests

app = Flask(__name__)

# AI Client
ai_client = OpenAI(
    api_key=os.environ["SKILLBOSS_API_KEY"],
    base_url="https://api.skillboss.co/v1"
)

API_BASE = "https://api.skillboss.co/v1"
API_KEY = os.environ["SKILLBOSS_API_KEY"]

# AI Chat endpoint
@app.route("/api/chat", methods=["POST"])
def chat():
    message = request.json.get("message")
    response = ai_client.chat.completions.create(
        model="deepseek/deepseek-v3",
        messages=[{"role": "user", "content": message}]
    )
    return jsonify({"reply": response.choices[0].message.content})

# Payment checkout
@app.route("/api/subscribe", methods=["POST"])
def subscribe():
    response = requests.post(
        f"{API_BASE}/payments/checkout",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "amount": 999,  # $9.99
            "currency": "usd",
            "success_url": f"{request.host_url}success",
            "cancel_url": f"{request.host_url}cancel"
        }
    )
    return jsonify(response.json())

# Send welcome email
@app.route("/api/welcome-email", methods=["POST"])
def welcome_email():
    email = request.json.get("email")
    response = requests.post(
        f"{API_BASE}/email/send",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "to": email,
            "subject": "Welcome to Our App!",
            "body": "Thanks for signing up. Start exploring our AI features!"
        }
    )
    return jsonify({"success": True})

# Generate image
@app.route("/api/generate-image", methods=["POST"])
def generate_image():
    prompt = request.json.get("prompt")
    response = requests.post(
        f"{API_BASE}/images/generations",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"prompt": prompt, "model": "flux/schnell"}
    )
    return jsonify(response.json())

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

Replit Deployment

Deploy with SkillBoss Backend

1. Build your app in Replit
2. Add SKILLBOSS_API_KEY to Secrets (not .env)
3. Click Deploy → Autoscale
4. Your app is live with AI, payments, email!

Environment Variables for Deployment

In Replit Secrets:

SKILLBOSS_API_KEY=sk-your-key

All SkillBoss services work in deployed Repls.

Cost Optimization

Free Tier Projects

Use ultra-cheap models:

model = "gemini/gemini-2.5-flash-lite"  # $0.01/1M tokens

Estimated Costs

Troubleshooting

curl https://api.skillboss.co/v1/models \
  -H "Authorization: Bearer $SKILLBOSS_API_KEY"

openai>=1.0.0
requests
flask

model = "gemini/gemini-2.5-flash"

import os
key = os.environ.get("SKILLBOSS_API_KEY")

FAQ

Next Steps