Python SDK

from fastapi import FastAPI
from keybox_sdk.client import protect_fastapi_app
import os

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from licensed app!"}

@app.get("/api/data")
def get_data():
    return {"data": [1, 2, 3, 4, 5]}

# Protect your app with a single function call
protect_fastapi_app(
    app=app,
    product_name="My API",
    key=os.getenv("LICENSE_KEY")
)

from fastapi import FastAPI, HTTPException
from keybox_sdk.client import protect_fastapi_app
from pydantic import BaseModel
import os
from dotenv import load_dotenv

load_dotenv()

app = FastAPI(
    title="My Protected API",
    description="This API is protected by KeyBox",
    version="1.0.0"
)

class Item(BaseModel):
    name: str
    description: str | None = None

@app.get("/")
def read_root():
    return {"message": "API is running"}

@app.get("/api/items")
def get_items():
    return {"items": []}

@app.post("/api/items")
def create_item(item: Item):
    return {"item": item, "status": "created"}

# Protect the entire application
protect_fastapi_app(
    app=app,
    product_name=os.getenv("PRODUCT_NAME"),
    key=os.getenv("LICENSE_KEY"),
    api_url=os.getenv("KEYBOX_API_URL", "https://api-keybox.vercel.app")
)

PRODUCT_NAME=My API
LICENSE_KEY=kb_xxxxxxxxxxxxx
KEYBOX_API_URL=https://api-keybox.vercel.app

from fastapi import FastAPI, HTTPException
from keybox_sdk.client import protect_fastapi_app
import os

app = FastAPI()

@app.get("/")
def read_root():
    return {
        "message": "This API is protected by KeyBox",
        "version": "1.0.0"
    }

@app.get("/api/data")
def get_data():
    return {
        "data": [1, 2, 3, 4, 5],
        "count": 5
    }

@app.get("/api/status")
def get_status():
    return {"status": "operational"}

try:
    protect_fastapi_app(
        app=app,
        product_name="My API",
        key=os.getenv("LICENSE_KEY")
    )
    print("✓ Application is protected by KeyBox")
except Exception as e:
    print(f"✗ Failed to protect application: {e}")
    exit(1)

import os
import sys
import time
from keybox_sdk.client import activate_license, start_license_daemon

def main():
    # Activate on startup
    try:
        result = activate_license(
            product_name="My CLI Tool",
            key=os.getenv("LICENSE_KEY")
        )
        print(f"✓ License activated: {result['status']}")
        if result.get('expiresAt'):
            print(f"  Expires: {result['expiresAt']}")
    except Exception as e:
        print(f"✗ License activation failed: {e}")
        print("Please contact support with a valid license key.")
        sys.exit(1)
    
    # Start background validation
    def on_invalid(data):
        print(f"\n⚠ License {data['status']}: {data.get('message')}")
        print("The tool will now exit.")
        os._exit(1)
    
    start_license_daemon(
        product_name="My CLI Tool",
        key=os.getenv("LICENSE_KEY"),
        on_stop=on_invalid
    )
    
    print("✓ License monitoring active")
    print("Running your CLI tool...\n")
    
    # Your CLI tool logic here
    run_cli_tool()

def run_cli_tool():
    """Your actual CLI tool logic"""
    while True:
        print("Processing...")
        time.sleep(5)

if __name__ == "__main__":
    main()

from django.apps import AppConfig
from keybox_sdk.client import activate_license, start_license_daemon
import os
import sys

class YourAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'yourapp'
    
    def ready(self):
        # Only run in main process (not in reloader)
        if os.environ.get('RUN_MAIN') == 'true':
            self.protect_with_keybox()
    
    def protect_with_keybox(self):
        try:
            # Activate license
            activate_license(
                product_name="My Django App",
                key=os.getenv("LICENSE_KEY")
            )
            print("✓ License activated")
            
            # Start daemon
            def on_invalid(data):
                print(f"\n⚠ License {data['status']}")
                print("Application will shutdown.")
                os._exit(1)
            
            start_license_daemon(
                product_name="My Django App",
                key=os.getenv("LICENSE_KEY"),
                on_stop=on_invalid
            )
            print("✓ License monitoring active")
            
        except Exception as e:
            print(f"✗ License protection failed: {e}")
            sys.exit(1)

from flask import Flask, jsonify
from keybox_sdk.client import activate_license, start_license_daemon
import os
import sys

app = Flask(__name__)

@app.route('/')
def index():
    return jsonify({"message": "Hello from licensed Flask app"})

@app.route('/api/data')
def get_data():
    return jsonify({"data": [1, 2, 3, 4, 5]})

if __name__ == '__main__':
    # Activate license before starting
    try:
        activate_license(
            product_name="My Flask App",
            key=os.getenv("LICENSE_KEY")
        )
        print("✓ License activated")
    except Exception as e:
        print(f"✗ Failed to activate: {e}")
        sys.exit(1)
    
    # Start daemon
    def on_revoke(data):
        print(f"\n⚠ License revoked: {data['status']}")
        os._exit(1)
    
    start_license_daemon(
        product_name="My Flask App",
        key=os.getenv("LICENSE_KEY"),
        on_stop=on_revoke
    )
    print("✓ License monitoring started")
    
    # Run Flask app
    app.run(host='0.0.0.0', port=5000)

import os
import sys
import pandas as pd
from keybox_sdk.client import activate_license, start_license_daemon

def main():
    # Protect your data science script
    try:
        activate_license(
            product_name="My Analysis Tool",
            key=os.getenv("LICENSE_KEY")
        )
        print("✓ Licensed to run analysis")
    except Exception as e:
        print(f"✗ License validation failed: {e}")
        print("Cannot run analysis without valid license.")
        sys.exit(1)
    
    # Start monitoring in background
    start_license_daemon(
        product_name="My Analysis Tool",
        key=os.getenv("LICENSE_KEY"),
        on_stop=lambda _: os._exit(1)
    )
    
    # Run your analysis
    print("Running data analysis...")
    df = pd.read_csv('data.csv')
    results = perform_analysis(df)
    results.to_csv('results.csv')
    print("✓ Analysis complete")

def perform_analysis(df):
    # Your analysis logic
    return df.describe()

if __name__ == "__main__":
    main()