Code Examples

curl -X POST https://api.inkog.io/api/v1/scan \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@./agent.py"

curl -X POST https://api.inkog.io/api/v1/scan \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@./src/agent.py" \
  -F "file=@./src/tools.py" \
  -F "file=@./src/prompts.py"

import requests
 
def scan_file(file_path: str, api_key: str) -> dict:
    """Scan a file for AI agent vulnerabilities."""
    with open(file_path, "rb") as f:
        response = requests.post(
            "https://api.inkog.io/api/v1/scan",
            headers={"Authorization": f"Bearer {api_key}"},
            files={"file": f}
        )
 
    response.raise_for_status()
    return response.json()
 
 
# Usage
result = scan_file("agent.py", "YOUR_API_KEY")
 
print(f"Risk Score: {result['risk_score']}/100")
print(f"Findings: {result['findings_count']}")
 
for finding in result["findings"]:
    print(f"  [{finding['severity']}] {finding['file']}:{finding['line']}")
    print(f"    {finding['message']}")

import requests
from pathlib import Path
 
def scan_directory(directory: str, api_key: str) -> dict:
    """Scan all Python files in a directory."""
    files = []
    for path in Path(directory).rglob("*.py"):
        files.append(("file", (path.name, open(path, "rb"))))
 
    response = requests.post(
        "https://api.inkog.io/api/v1/scan",
        headers={"Authorization": f"Bearer {api_key}"},
        files=files
    )
 
    # Clean up file handles
    for _, (_, f) in files:
        f.close()
 
    response.raise_for_status()
    return response.json()
 
 
result = scan_directory("./src", "YOUR_API_KEY")
print(f"Scanned {result['files_scanned']} files")

async function scanFile(filePath, apiKey) {
  const formData = new FormData();
  const file = await fetch(filePath).then(r => r.blob());
  formData.append('file', file, filePath.split('/').pop());
 
  const response = await fetch('https://api.inkog.io/api/v1/scan', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`
    },
    body: formData
  });
 
  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error?.message || 'Scan failed');
  }
 
  return response.json();
}
 
// Usage
const result = await scanFile('./agent.js', 'YOUR_API_KEY');
console.log(`Risk Score: ${result.risk_score}/100`);
console.log(`Found ${result.findings_count} issues`);

import fs from 'fs';
import FormData from 'form-data';
 
async function scanFile(filePath, apiKey) {
  const form = new FormData();
  form.append('file', fs.createReadStream(filePath));
 
  const response = await fetch('https://api.inkog.io/api/v1/scan', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      ...form.getHeaders()
    },
    body: form
  });
 
  return response.json();
}

package main
 
import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
)
 
type ScanResult struct {
	Success       bool      `json:"success"`
	RiskScore     int       `json:"risk_score"`
	FindingsCount int       `json:"findings_count"`
	Findings      []Finding `json:"findings"`
}
 
type Finding struct {
	ID       string `json:"id"`
	Severity string `json:"severity"`
	File     string `json:"file"`
	Line     int    `json:"line"`
	Message  string `json:"message"`
	CWE      string `json:"cwe"`
}
 
func ScanFile(filePath, apiKey string) (*ScanResult, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()
 
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
 
	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
	if err != nil {
		return nil, err
	}
	io.Copy(part, file)
	writer.Close()
 
	req, err := http.NewRequest("POST", "https://api.inkog.io/api/v1/scan", body)
	if err != nil {
		return nil, err
	}
 
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", writer.FormDataContentType())
 
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
 
	var result ScanResult
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}
 
	return &result, nil
}
 
func main() {
	result, err := ScanFile("agent.go", "YOUR_API_KEY")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
 
	fmt.Printf("Risk Score: %d/100\n", result.RiskScore)
	fmt.Printf("Findings: %d\n", result.FindingsCount)
 
	for _, f := range result.Findings {
		fmt.Printf("  [%s] %s:%d - %s\n", f.Severity, f.File, f.Line, f.Message)
	}
}

inkog scan ./src