API Documentation

Authorization: Bearer rl_your_api_key_here

{
  "mcpServers": {
    "status200-uploads": {
      "url": "https://mcp.status200uploads.com/mcp",
      "headers": {
        "Authorization": "Bearer rl_put_your_dashboard_key_here"
      }
    }
  }
}

import requests
from datetime import datetime, timedelta

API_KEY = "rl_your_api_key"
BASE_URL = "https://app.status200uploads.com/functions/v1"
HEADERS = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

# Define your content schedule
schedule = [
    {"platform": "tiktok", "account": "@mytiktok", "hour": 9},
    {"platform": "instagram", "account": "@myinsta", "hour": 12},
    {"platform": "x", "account": "@mytwitter", "hour": 15},
    {"platform": "linkedin", "account": "@mylinkedin", "hour": 17},
]

# Upload media once
media_resp = requests.post(
    f"{BASE_URL}/api-media-upload",
    headers=HEADERS,
    json={"url": "https://example.com/content.mp4"}
)
file_id = media_resp.json()["file_id"]

# Schedule posts across platforms
tomorrow = datetime.now() + timedelta(days=1)
for item in schedule:
    scheduled_time = tomorrow.replace(
        hour=item["hour"], minute=0, second=0
    ).isoformat() + "Z"

    resp = requests.post(
        f"{BASE_URL}/api-posts",
        headers=HEADERS,
        json={
            "post": {
                "accountId": item["account"],
                "platform": item["platform"],
                "content": {
                    "text": "Check out our latest content!",
                    "mediaID": [file_id]
                },
                "scheduledFor": scheduled_time
            }
        }
    )
    status = "OK" if resp.json().get("success") else "FAIL"
    print(f"{item['platform']}: {status} at {scheduled_time}")

npm install @status200/uploads-node

import { Status200 } from '@status200/uploads-node';

const client = new Status200({ apiKey: process.env.STATUS200_API_KEY });

// Upload media
const media = await client.media.upload({
  url: 'https://example.com/video.mp4'
});

// Create a post
const post = await client.posts.create({
  accountId: '@myprofile',
  platform: 'tiktok',
  content: {
    text: 'Automated with the Node SDK!',
    mediaID: [media.file_id]
  },
  tiktok: {
    privacyLevel: 'PUBLIC_TO_EVERYONE'
  }
});

console.log('Published:', post.post_id);

// List posts
const { posts } = await client.posts.list({
  platform: 'tiktok',
  limit: 10
});

// Get analytics
const metrics = await client.analytics.get(post.post_id);
console.log('Views:', metrics.views);

pip install status200-uploads

from status200 import Status200Client

client = Status200Client(api_key="rl_your_api_key")

# Upload media
media = client.media.upload(url="https://example.com/video.mp4")

# Create a post
post = client.posts.create(
    account_id="@myprofile",
    platform="tiktok",
    content={
        "text": "Automated with Python SDK!",
        "mediaID": [media.file_id]
    },
    tiktok={"privacyLevel": "PUBLIC_TO_EVERYONE"}
)

print(f"Published: {post.post_id}")

# List posts
posts = client.posts.list(platform="tiktok", limit=10)

# Async support
import asyncio
from status200 import AsyncStatus200Client

async def main():
    async_client = AsyncStatus200Client(api_key="rl_your_api_key")
    post = await async_client.posts.create(...)
    await async_client.close()

asyncio.run(main())

import crypto from 'crypto';

function verifyWebhookSignature(body, signature, secret) {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(body, 'utf8')
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}

// In your webhook handler:
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-webhook-signature'];
  const isValid = verifyWebhookSignature(req.body, sig, WEBHOOK_SECRET);

  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(req.body);
  // Process the event...

  res.status(200).send('OK');
});

import hmac
import hashlib

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    expected = 'sha256=' + hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

# In your Flask handler:
@app.route('/webhook', methods=['POST'])
def webhook():
    sig = request.headers.get('X-Webhook-Signature', '')
    if not verify_signature(request.data, sig, WEBHOOK_SECRET):
        return 'Invalid signature', 401

    event = request.json
    # Process the event...

    return 'OK', 200