API Reference

# Using the demo key
curl -X POST https://slopshop.gg/v1/text-reverse \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{"text": "hello world"}'

const response = await fetch('https://slopshop.gg/v1/text-reverse', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ text: 'hello world' }),
});
const data = await response.json();
console.log(data);

# Sign up and get 500 free credits
curl -X POST https://slopshop.gg/v1/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"email": "dev@example.com", "name": "My Agent"}'

https://slopshop.gg/v1

POST /v1/{slug} HTTP/1.1
Host: slopshop.gg
Authorization: Bearer sk-slop-...
Content-Type: application/json

{
  // Tool-specific input fields
  "text": "hello world",

  // Optional: mode controls
  "mode": "agent",           // Enable agent mode
  "trace": true,             // Enable debug trace
  "session_id": "my-session" // For agent memory persistence
}

curl -X POST https://slopshop.gg/v1/hash-sha256 \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{"input": "my important data"}'

import requests

resp = requests.post(
    "https://slopshop.gg/v1/hash-sha256",
    headers={"Authorization": "Bearer sk-slop-demo-key-12345678"},
    json={"input": "my important data"},
)
print(resp.json())

{
  "ok": true,
  "data": {
    // Tool-specific output
    "hash": "a1b2c3d4...",
    "_engine": "real"
  },
  "meta": {
    "api": "hash-sha256",
    "credits_used": 1,
    "balance": 1999,
    "latency_ms": 3,
    "engine": "real",
    "confidence": 0.99,
    "output_hash": "sha256-of-data..."
  },
  "guarantees": {
    "schema_valid": true,
    "validated": true,
    "fallback_used": false
  }
}

# Use -i to see response headers
curl -i -X POST https://slopshop.gg/v1/uuid-generate \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{}'

{
  "error": {
    "code": "insufficient_credits",
    "message": "Need 5 credits, have 2",
    "need": 5,
    "have": 2
  }
}

# Missing auth header returns 401 with demo key hint
curl -X POST https://slopshop.gg/v1/text-reverse \
  -H "Content-Type: application/json" \
  -d '{"text": "test"}'

# Response:
# {"error":{"code":"auth_required","message":"Set Authorization: Bearer <key>",
#   "demo_key":"sk-slop-demo-key-12345678","signup":"POST /v1/auth/signup"}}

const res = await fetch('https://slopshop.gg/v1/text-reverse', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ text: 'hello' }),
});

if (!res.ok) {
  const err = await res.json();
  if (res.status === 402) {
    console.log(`Need ${err.error.need} credits, have ${err.error.have}`);
  } else if (res.status === 429) {
    const retryAfter = res.headers.get('Retry-After');
    console.log(`Rate limited. Retry in ${retryAfter}s`);
  } else {
    console.error(err.error.code, err.error.message);
  }
}

# Check current rate limit status in response headers
curl -i -X POST https://slopshop.gg/v1/uuid-generate \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{}'

# Look for: X-RateLimit-Remaining, Retry-After

import requests, time

def call_api(slug, body):
    resp = requests.post(
        f"https://slopshop.gg/v1/{slug}",
        headers={"Authorization": "Bearer sk-slop-demo-key-12345678"},
        json=body,
    )
    if resp.status_code == 429:
        wait = int(resp.headers.get("Retry-After", 5))
        print(f"Rate limited. Waiting {wait}s...")
        time.sleep(wait)
        return call_api(slug, body)  # retry
    return resp.json()

# Use -v to see all response headers
curl -v -X POST https://slopshop.gg/v1/text-word-count \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{"text": "The quick brown fox"}'

# Response headers include:
# X-Request-Id: 550e8400-e29b-41d4-a716-446655440000
# X-Credits-Used: 1
# X-Credits-Remaining: 199
# X-Latency-Ms: 2
# X-Engine: real
# X-Cost-USD: 0.0050
# X-Output-Hash: a1b2c3d4e5f6...

const res = await fetch('https://slopshop.gg/v1/text-word-count', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ text: 'The quick brown fox' }),
});

console.log('Request ID:', res.headers.get('X-Request-Id'));
console.log('Credits used:', res.headers.get('X-Credits-Used'));
console.log('Remaining:', res.headers.get('X-Credits-Remaining'));
console.log('Latency:', res.headers.get('X-Latency-Ms'), 'ms');
console.log('Engine:', res.headers.get('X-Engine'));
console.log('Cost:', res.headers.get('X-Cost-USD'));
console.log('Output hash:', res.headers.get('X-Output-Hash'));

curl -X POST https://slopshop.gg/v1/validate-email \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "mode": "agent",
    "session_id": "research-session-42"
  }'

# Response includes an "agent" block:
# {
#   "ok": true,
#   "data": { ... },
#   "agent": {
#     "suggestions": ["validate-phone", "pii-detect", "text-sanitize"],
#     "cache_fingerprint": "a1b2c3d4...",
#     "cost_breakdown": { "this_call": 1, "memory_cost": 0, "potential_cache_savings": 1 },
#     "memory_persisted": { "namespace": "research-session-42", "key": "validate-email:a1b2c3d4" }
#   }
# }

const res = await fetch('https://slopshop.gg/v1/validate-email', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
    'X-Agent-Mode': 'true',  // alternative to "mode": "agent"
  },
  body: JSON.stringify({
    email: 'user@example.com',
    session_id: 'research-session-42',
  }),
});

const { data, agent } = await res.json();
console.log('Result:', data);
console.log('Next tools to try:', agent.suggestions);
console.log('Memory saved at:', agent.memory_persisted);

# Stream results via SSE
curl -N -X POST https://slopshop.gg/v1/stream/text-reverse \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{"text": "stream this"}'

# Output (Server-Sent Events):
# event: start
# data: {"slug":"text-reverse","credits":1,"ts":"2026-03-27T..."}
#
# event: progress
# data: {"status":"executing","slug":"text-reverse","percent":0}
#
# event: result
# data: {"reversed":"siht maerts","_engine":"real"}
#
# event: done
# data: {"ok":true,"latency_ms":4}

const res = await fetch('https://slopshop.gg/v1/stream/text-reverse', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ text: 'stream this' }),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  const chunk = decoder.decode(value);
  // Parse SSE events
  for (const line of chunk.split('\n')) {
    if (line.startsWith('data: ')) {
      const event = JSON.parse(line.slice(6));
      console.log(event);
    }
  }
}

# Subscribe to real-time usage events for your account
curl -N https://slopshop.gg/v1/stream/usage \
  -H "Authorization: Bearer sk-slop-demo-key-12345678"

curl -X POST https://slopshop.gg/v1/batch \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{
    "calls": [
      { "slug": "uuid-generate", "input": {} },
      { "slug": "text-reverse", "input": { "text": "batch test" } },
      { "slug": "hash-sha256", "input": { "input": "important data" } }
    ]
  }'

# Response:
# {
#   "ok": true,
#   "results": [
#     { "slug": "uuid-generate", "data": {...}, "credits": 1, "latency_ms": 1 },
#     { "slug": "text-reverse", "data": {...}, "credits": 1, "latency_ms": 2 },
#     { "slug": "hash-sha256", "data": {...}, "credits": 1, "latency_ms": 1 }
#   ],
#   "total_credits": 3,
#   "balance": 197,
#   "calls_count": 3
# }

const res = await fetch('https://slopshop.gg/v1/batch', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    calls: [
      { slug: 'uuid-generate', input: {} },
      { slug: 'text-reverse', input: { text: 'batch test' } },
      { slug: 'hash-sha256', input: { input: 'important data' } },
    ],
  }),
});

const { results, total_credits, balance } = await res.json();
console.log(`Executed ${results.length} calls for ${total_credits} credits`);
results.forEach(r => console.log(r.slug, r.data));

import requests

resp = requests.post(
    "https://slopshop.gg/v1/batch",
    headers={"Authorization": "Bearer sk-slop-demo-key-12345678"},
    json={
        "calls": [
            {"slug": "uuid-generate", "input": {}},
            {"slug": "text-reverse", "input": {"text": "batch test"}},
            {"slug": "hash-sha256", "input": {"input": "important data"}},
        ]
    },
)

data = resp.json()
print(f"Total credits: {data['total_credits']}, Balance: {data['balance']}")
for r in data["results"]:
    print(r["slug"], r["data"])

curl -X POST https://slopshop.gg/v1/dry-run/hash-sha256 \
  -H "Authorization: Bearer sk-slop-demo-key-12345678" \
  -H "Content-Type: application/json" \
  -d '{"input": "test data"}'

# Response (no credits charged):
# {
#   "ok": true,
#   "dry_run": true,
#   "slug": "hash-sha256",
#   "name": "SHA-256 Hash",
#   "credits": 1,
#   "estimated_cost_usd": "0.0090",
#   "can_afford": true,
#   "balance": 200,
#   "balance_after": 199,
#   "has_handler": true,
#   "input_schema": { "required": ["input"], ... },
#   "input_validation": { "valid": true, "missing_fields": [] },
#   "hints": {
#     "execute": "POST /v1/hash-sha256",
#     "stream": "POST /v1/stream/hash-sha256",
#     "async": "POST /v1/async/hash-sha256"
#   }
# }

// Check cost before executing
const preview = await fetch('https://slopshop.gg/v1/dry-run/hash-sha256', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-slop-demo-key-12345678',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ input: 'test data' }),
}).then(r => r.json());

if (preview.can_afford && preview.input_validation.valid) {
  console.log(`Proceeding. Cost: ${preview.credits} credits ($${preview.estimated_cost_usd})`);
  // Now execute the real call
  const result = await fetch('https://slopshop.gg/v1/hash-sha256', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer sk-slop-demo-key-12345678',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ input: 'test data' }),
  }).then(r => r.json());
  console.log(result);
} else {
  console.log('Cannot proceed:', preview.input_validation);
}

npm install slopshop

const Slop = require('slopshop');

const slop = new Slop('sk-slop-demo-key-12345678');

// Call any API by slug
const result = await slop.call('text-reverse', { text: 'hello' });
console.log(result.data);
// { reversed: "olleh", _engine: "real" }

// Batch multiple calls
const batch = await slop.batch([
  { slug: 'uuid-generate', input: {} },
  { slug: 'hash-sha256', input: { input: 'data' } },
]);
console.log(batch.results);

// Check balance
const balance = await slop.balance();
console.log(`Credits remaining: ${balance.credits}`);

// Dry run
const preview = await slop.dryRun('hash-sha256', { input: 'test' });
console.log(`Cost: ${preview.credits} credits`);

// Stream
const stream = await slop.stream('text-reverse', { text: 'stream me' });
stream.on('result', data => console.log(data));
stream.on('done', () => console.log('Complete'));

const slop = new Slop('sk-slop-demo-key-12345678', { agentMode: true });

// Every call now returns suggestions + auto-persists to memory
const result = await slop.call('validate-email', {
  email: 'test@example.com',
  session_id: 'onboarding-flow',
});
console.log(result.agent.suggestions);
// ["validate-phone", "pii-detect", ...]

pip install slopshop

from slopshop import Slop

slop = Slop("sk-slop-demo-key-12345678")

# Call any API by slug
result = slop.call("text-reverse", text="hello")
print(result.data)
# {"reversed": "olleh", "_engine": "real"}

# Batch multiple calls
batch = slop.batch([
    {"slug": "uuid-generate", "input": {}},
    {"slug": "hash-sha256", "input": {"input": "data"}},
])
print(batch.results)

# Check balance
balance = slop.balance()
print(f"Credits remaining: {balance.credits}")

# Dry run
preview = slop.dry_run("hash-sha256", input="test")
print(f"Cost: {preview.credits} credits")

# Stream
for event in slop.stream("text-reverse", text="stream me"):
    print(event.type, event.data)

import asyncio
from slopshop import AsyncSlop

async def main():
    slop = AsyncSlop("sk-slop-demo-key-12345678")

    # Concurrent calls
    results = await asyncio.gather(
        slop.call("uuid-generate"),
        slop.call("text-reverse", text="async"),
        slop.call("hash-sha256", input="data"),
    )
    for r in results:
        print(r.data)

asyncio.run(main())

# Download the OpenAPI spec
curl https://slopshop.gg/v1/openapi.json -o openapi.json

# Or access it directly in your browser:
# https://slopshop.gg/v1/openapi.json

// Fetch and parse the OpenAPI spec
const spec = await fetch('https://slopshop.gg/v1/openapi.json').then(r => r.json());
console.log(`${Object.keys(spec.paths).length} endpoints available`);

// List all API slugs
for (const [path, methods] of Object.entries(spec.paths)) {
  console.log(path, methods.post?.summary);
}

import requests

spec = requests.get("https://slopshop.gg/v1/openapi.json").json()
print(f"{len(spec['paths'])} endpoints available")

for path, methods in spec["paths"].items():
    print(path, methods.get("post", {}).get("summary", ""))

# Add Slopshop as an MCP server in Claude Code
npx -y slopshop mcp

# Or with your own API key
SLOP_KEY=sk-slop-your-key npx -y slopshop mcp

{
  "mcpServers": {
    "slopshop": {
      "command": "npx",
      "args": ["-y", "slopshop", "mcp"],
      "env": {
        "SLOP_KEY": "sk-slop-demo-key-12345678"
      }
    }
  }
}

User: "Hash my password 'secret123' with SHA-256"

Claude uses tool: slopshop.hash-sha256({ input: "secret123" })
Result: { hash: "fcb3...", algorithm: "sha256", _engine: "real" }

Claude: "Here's the SHA-256 hash: fcb3..."

# Check the AI tools manifest (used by MCP clients)
curl https://slopshop.gg/.well-known/ai-tools.json