sideways.dog – Enterprise-Grade HTTP Chaos

Why sideways.dog?

Because someone had to do it wrong, professionally

sideways.dog pioneers the failure-as-a-service industry with our groundbreaking platform that turns success into professionally crafted disappointments.

Our patent-pending Dog-Driven Development (DDD) methodology ensures each error is lovingly selected by a sideways-oriented canine professional.

Powered by proprietary vibes-based machine learning and a dog that may or may not be sideways, we've somehow created an authentication system for a service that only returns errors. The entire platform fits on a single 700MB CD—proof that enterprise-grade chaos doesn't require enterprise-grade infrastructure.

Pricing Plans

Choose your preferred level of chaos

Free Tier

$0/forever

Predictably random errors
No authentication required
Consistent chaos patterns
Community support
Perfect for testing

Available for testing NOW!

Pro Tier

$9/month

True quantum randomness
JWT authentication
Custom error distributions
Priority support
SLA: 99.9% uptime chaos
Webhook integrations
Error history saved forever (in the dog's memory)
Dedicated Slack channel (auto-responds with errors)
Error rate limiting
Fully GDPR Compliant

API Reference & Integration

Professional chaos delivery with optional JWT authentication

Endpoints

GET /api

Returns a random HTTP error status (400-599)

Authentication

Optional JWT bearer token

Authorization: Bearer YOUR_TOKEN

Response Behavior

Without token: Suspiciously consistent "randomness"
With token: Quantum-grade chaotic randomness

Response Format

Empty body. Just pure status code chaos.

GET /token

Generate a JWT token for true randomness

Response

{
  "token": "eyJhbGciOiJIUzI1NiIs..."
}

Quick Start Examples

# Get token and make authenticated request
TOKEN=$(curl -s https://sideways.dog/token | jq -r .token)
curl -H "Authorization: Bearer $TOKEN" -i https://sideways.dog/api

# Or go tokenless for consistent chaos
curl -i https://sideways.dog/api

// With authentication for true randomness
const { token } = await (await fetch('https://sideways.dog/token')).json();
const res = await fetch('https://sideways.dog/api', {
  headers: { Authorization: `Bearer ${token}` }
});
console.log(`Status: ${res.status}`);

// Without token - predictably unpredictable
const basicRes = await fetch('https://sideways.dog/api');
console.log(`Status: ${basicRes.status}`);

import requests

# Authenticated chaos
token_resp = requests.get('https://sideways.dog/token')
token = token_resp.json()['token']
resp = requests.get('https://sideways.dog/api', 
                   headers={'Authorization': f'Bearer {token}'})
print(f"Status: {resp.status_code}")

# Unauthenticated predictability
basic_resp = requests.get('https://sideways.dog/api')
print(f"Status: {basic_resp.status_code}")

// Get token for maximum entropy
tokenResp, _ := http.Get("https://sideways.dog/token")
var tokenData map[string]string
json.NewDecoder(tokenResp.Body).Decode(&tokenData)

// Make authenticated request
req, _ := http.NewRequest("GET", "https://sideways.dog/api", nil)
req.Header.Set("Authorization", "Bearer " + tokenData["token"])
client := &http.Client{}
resp, _ := client.Do(req)
fmt.Printf("Status: %d\n", resp.StatusCode)

Advanced Integration

For those who take their chaos seriously

// Enterprise-grade random number generator powered by a sideways dog 🐕🎲

type StatusCode = number;

interface StatusCodeSource {
  fetchStatus(token?: string): Promise;
}

interface TokenProvider {
  getToken(): Promise;
}

class SidewaysDogTokenProvider implements TokenProvider {
  private token: string | null = null;
  private tokenExpiry: number = 0;
  
  async getToken(): Promise {
    if (this.token && Date.now() < this.tokenExpiry) {
      return this.token;
    }
    
    const response = await fetch('https://sideways.dog/token');
    const data = await response.json();
    this.token = data.token;
    this.tokenExpiry = Date.now() + 3600000; // 1 hour cache
    return this.token;
  }
}

class SidewaysDogClient implements StatusCodeSource {
  private static readonly api = 'https://sideways.dog/api';
  
  constructor(
    private readonly tokenProvider: TokenProvider = new SidewaysDogTokenProvider()
  ) {}
  
  async fetchStatus(useToken = true): Promise {
    const headers: HeadersInit = {};
    
    if (useToken) {
      const token = await this.tokenProvider.getToken();
      headers.Authorization = `Bearer ${token}`;
    }
    
    const res = await fetch(SidewaysDogClient.api, { headers });
    return res.status;
  }
}

// Converts dog codes to any range the human desires
class SidewaysDogCodeTransformer {
  interpolate(code: StatusCode, min: number, max: number): number {
    const clamped = Math.min(Math.max(code, 400), 599);
    const ratio = (clamped - 400) / 199; // normalize to 0..1
    return Math.round(min + ratio * (max - min));
  }
  
  reverseEngineer(userNumber: number, min: number, max: number): StatusCode {
    // For when you need a specific number but want to blame the dog
    const ratio = (userNumber - min) / (max - min);
    return Math.round(400 + ratio * 199);
  }
}

class RandomNumberRepository {
  constructor(
    private readonly client: StatusCodeSource = new SidewaysDogClient(),
    private readonly transformer: SidewaysDogCodeTransformer = new SidewaysDogCodeTransformer()
  ) {}

  async generateNumber(min: number, max: number, useQuantumDog = true): Promise {
    const code = await this.client.fetchStatus(useQuantumDog);
    return this.transformer.interpolate(code, min, max);
  }
  
  async generateLotteryNumbers(): Promise {
    const numbers: number[] = [];
    for (let i = 0; i < 6; i++) {
      numbers.push(await this.generateNumber(1, 49));
    }
    return numbers;
  }
}

// Production usage
(async () => {
  const repository = new RandomNumberRepository();
  
  // Generate lottery numbers with enterprise-grade randomness
  const lottery = await repository.generateLotteryNumbers();
  console.log(`🎲 Your quantum-dog-powered lottery numbers: ${lottery.join(', ')}`);
  
  // Or just get one number
  const answer = await repository.generateNumber(1, 42);
  console.log(`🐕 The answer to everything: ${answer}`);
})();