404 - Page Not Found

You have come to this page because the link you are visiting is not found.

Open Source Edge Platform

Build Your Own
CDN & Edge Network

Enterprise-grade reverse proxy and API gateway built on OpenResty. Deploy globally with load balancing, edge caching, SSL automation, and WAF protection—all in one platform.

Get Started Free View Documentation
OpenResty Lua Redis Docker Kubernetes
99.99%
Uptime SLA
<10ms
Edge Latency
1M+
Requests/sec
$ curl -X POST /api/servers
{
  "server_name": "api.example.com",
  "upstream": "192.168.1.100:8080",
  "ssl_enabled": true,
  "cache_enabled": true,
  "waf_enabled": true
}
$ curl /metrics
nginx_cache_hits_total 847293
nginx_http_requests_total 2.3M
nginx_upstream_latency_avg 8.2ms
Features

Everything You Need at the Edge

A complete platform for routing, caching, security, and observability—built for modern cloud-native applications.

Smart Load Balancing

Distribute traffic across multiple backends with intelligent algorithms and automatic failover.

  • Health checks & auto-failover
  • Session persistence
  • Weighted routing

Multi-Region Failover

Deploy across multiple regions with automatic DNS failover and geo-distributed redundancy.

  • Active-active clustering
  • Geo-DNS routing
  • Region affinity rules

Edge Caching

Cache static content at the edge for blazing-fast delivery and reduced origin load.

  • Per-server cache control
  • Smart cache invalidation
  • Cache analytics & metrics

Build Your Own CDN

Create a private CDN infrastructure tailored to your needs without vendor lock-in.

  • Custom edge locations
  • Origin shielding
  • Real-time purging

WAF & Security

Protect applications with enterprise-grade Web Application Firewall and DDoS mitigation.

  • OWASP rule sets
  • Rate limiting
  • IP & geo blocking

Automatic SSL/TLS

Zero-touch SSL certificate management with Let's Encrypt auto-provisioning and renewal.

  • Auto-provisioning
  • Wildcard certificates
  • TLS 1.3 support

API Gateway

Full-featured API gateway with authentication, rate limiting, and request transformation.

  • JWT authentication
  • API key management
  • OpenAPI integration

Full Observability

Complete visibility with Prometheus metrics, structured logging, and real-time analytics.

  • Prometheus metrics
  • Grafana dashboards
  • Custom alerting

Admin Dashboard

Intuitive React-based admin interface to manage servers, rules, and configurations.

  • Server management UI
  • Live traffic view
  • User management

Geo Traffic Rules

Control web traffic with geo-tagging rules per country, continent, or custom regions.

  • Country-level blocking
  • Continent-based routing
  • Geo-IP database integration

Edge Compression

Compress responses at the edge with Gzip and Brotli for faster delivery and reduced bandwidth.

  • Gzip & Brotli support
  • Content-type aware
  • Dynamic compression levels

Ingress Integration

Native Kubernetes Ingress controller with annotations for advanced traffic management.

  • Ingress controller
  • Annotation-based config
  • IngressClass support

Secrets Management

Built-in secrets management with HashiCorp Vault integration for secure credential handling.

  • HashiCorp Vault integration
  • Dynamic secrets rotation
  • Encrypted storage

Cloud Cert Pipelines

Integrate with AWS ACM, Azure Key Vault, GCP Certificate Manager for enterprise cert workflows.

  • AWS ACM integration
  • Azure Key Vault support
  • GCP Cert Manager

Content-Based WAF

Inspect request/response bodies with content-aware WAF rules for deep threat detection.

  • Body inspection rules
  • JSON/XML parsing
  • Custom regex patterns

SQL Injection Protection

Advanced SQL injection detection and mitigation with pattern matching and heuristic analysis.

  • SQLi pattern detection
  • Parameterized query analysis
  • Attack logging & alerts

GitOps Ready

Deploy and manage configurations via Git with ArgoCD and Flux integration—works like a charm.

  • ArgoCD & Flux support
  • Declarative configs
  • Git-based rollbacks

Edge Authorization

API Gateway protection with authorization at the edge—authenticate before traffic reaches your origins.

  • OAuth2 & OIDC support
  • JWT validation at edge
  • Role-based access control

AI Agent & MCP Server

Built-in Model Context Protocol (MCP) server enabling AI agents like Claude, GPT, and Cursor to securely discover and interact with gateway configuration and status.

  • MCP JSON-RPC 2.0 & REST endpoints
  • Read-only resources with secret redaction
  • Feature-flagged tools (config validation, logs)
  • API key auth & read-only mode by default

Slack Community

Join our active Slack community for support, deployment help, and scaling high-performance systems.

  • Real-time support
  • Deployment guidance
  • Performance tuning tips

Monitoring Integration

Native integration with leading monitoring and observability platforms for complete visibility.

  • Prometheus, Grafana, Loki, Mimir
  • ELK Stack & Alertmanager
  • Dynatrace & Datadog
How It Works

Deploy in Minutes, Not Days

Get your edge infrastructure up and running with just a few simple steps.

1

Deploy WSL Proxy

Launch using Docker, Kubernetes, or bare metal with one-line deployment.

2

Configure Servers

Add backends via REST API or admin dashboard with routing rules.

3

Enable Features

Turn on SSL, caching, WAF, and load balancing per server.

4

Monitor & Scale

Track performance with metrics and scale as traffic grows.

Architecture

Explore the Architecture

Deep dive into WSL Proxy's architecture with interactive diagrams. View CI/CD pipelines, Kubernetes deployment, and request flow.

Platform Architecture

Complete overview of WSL Proxy components: WAF, SSL, Cache, Load Balancer, Router, and integrations with Redis and origin servers.

  • Edge layer components
  • Data flow visualization
  • Multi-region setup
View Diagram

CI/CD Pipeline

Full CI/CD integration with GitHub Actions, Ansible playbooks, and Kubernetes Helm deployments across environments.

  • GitHub Actions workflow
  • Ansible deployment
  • Multi-environment support
View Diagram

Kubernetes & Scaling

Helm chart structure, HPA auto-scaling, pod deployment, and service configuration for production workloads.

  • Helm chart templates
  • HPA auto-scaling
  • Rolling deployments
View Diagram

Request Flow

Step-by-step request processing: DNS → SSL → WAF → Auth → Cache → Load Balancer → Origin → Response.

  • 13-step flow diagram
  • Cache hit/miss paths
  • Lua module mapping
View Diagram

Web UI Control Plane

Fully-featured Web UI Administrator control plane to manage entire cluster configuration from a single place securely.

  • Centralized management
  • Role-based access control
  • Real-time configuration
Open Admin Panel
API Documentation All Diagrams on GitHub
Request Flow

How Requests Are Processed

Every request flows through our intelligent pipeline—no restarts required. Configuration changes take effect immediately via API.

Client
→
DNS
→
SSL/TLS
→
WAF
→
Auth
→
Cache
→
Load Balancer
→
Origin
🔄

Zero Downtime

All configuration changes via API—no OpenResty restart needed. Changes take effect instantly.

⚡

Hot Reload

Add servers, update routes, toggle caching—all without interrupting active connections.

🌍

Multi-Region Failover

Automatic failover between regions. If one origin fails, traffic routes to healthy backends instantly.

📡

API-First

Every feature controllable via REST API. Integrate with your CI/CD, scripts, or admin dashboard.

API-Driven

Everything Via REST API

No restarts. No downtime. Manage your entire edge infrastructure through simple API calls.

POST /api/servers

🖥️ Manage Servers

Add, update, or remove backend servers with load balancing and health checks.

{
  "server_name": "api.example.com",
  "upstream": "192.168.1.100:8080",
  "ssl_enabled": true,
  "cache_enabled": true
}
POST /api/rules

🛡️ Security Rules

Configure WAF rules, rate limiting, IP blocking—all live without restart.

{
  "rule_type": "rate_limit",
  "path": "/api/*",
  "limit": "100/minute",
  "action": "block"
}
POST /api/cache/purge

⚡ Cache Control

Purge cache, enable/disable per server, set TTL—instant effect.

{
  "server_name": "api.example.com",
  "purge_pattern": "/static/*",
  "action": "purge"
}
POST /api/ssl/provision

🔒 SSL Certificates

Auto-provision Let's Encrypt certificates or upload custom certs.

{
  "domain": "api.example.com",
  "provider": "letsencrypt",
  "auto_renew": true
}
GET /metrics

📊 Prometheus Metrics

Real-time metrics for Prometheus/Grafana—requests, latency, cache stats.

nginx_http_requests_total 2847293
nginx_cache_hits_total 1923847
nginx_upstream_latency_avg 8.2
GET /api/health

💚 Health Check

Check proxy health, backend status, and service availability.

{
  "status": "healthy",
  "uptime": "45d 12h 30m",
  "backends": 12,
  "backends_healthy": 12
}
Full API Documentation
CI/CD Pipeline

Automated Deployment Pipeline

From code commit to production deployment—fully automated with GitHub Actions, Ansible, and Helm.

1
Code Push

Git commit

→
2
GitHub Actions

Lint, Test, Build

→
3
Docker Build

Multi-arch image

→
4
Push Registry

Docker Hub/GHCR

→
5
Deploy

Ansible / Helm

Ansible Deployment

For bare metal and VM deployments

ansible-playbook deploy.yml \
  --tags nginx \
  -i inventory/production
  • Zero-downtime reload
  • Config templating (Jinja2)
  • Vault secrets

Kubernetes / Helm

For cloud-native container deployments

helm upgrade --install wslproxy \
  ./chart -n production \
  -f values-prod.yaml
  • Rolling updates
  • HPA auto-scaling
  • Multi-replica HA
Multi-Region

Global Multi-Region Failover

Deploy across multiple regions with automatic failover. Zero downtime when origins fail.

🇺🇸
US-East

Primary

⟷
WSL Proxy

Edge Router

⟷
🇪🇺
EU-West

Secondary

⟷
🇯🇵
Asia-Pacific

Tertiary

Health Checks

Continuous monitoring of all backends

Instant Failover

<100ms failover time

Weighted Routing

Traffic distribution control

Geo Routing

Route by user location

POST /api/servers — Configure multi-region backend 
{
  "server_name": "api.example.com",
  "upstreams": [
    { "host": "us-east.origin.com:8080", "weight": 5, "primary": true },
    { "host": "eu-west.origin.com:8080", "weight": 3, "backup": false },
    { "host": "asia.origin.com:8080", "weight": 2, "backup": true }
  ],
  "health_check": { "interval": "5s", "timeout": "2s", "unhealthy_threshold": 3 },
  "failover": { "enabled": true, "strategy": "round_robin" }
}
Use Cases

Built for Every Workload

From startups to enterprises, WSL Proxy powers diverse applications across industries.

🛒

E-Commerce

Fast page loads and secure checkout with edge caching and WAF.

📱

Mobile Apps

Low-latency API responses with global edge presence.

🎮

Gaming

Real-time server routing with sub-10ms latency.

🎬

Media Streaming

Efficient video delivery with edge caching.

🏦

FinTech

Secure APIs with JWT auth and rate limiting.

🏥

Healthcare

Compliant routing with encryption and audit trails.

50+
Edge Locations Ready
10B+
Requests Handled
500+
Active Deployments
24/7
Community Support
Pricing

Simple, Transparent Pricing

Start free, scale as you grow. Enterprise features included.

Community
Free forever
  • Unlimited servers
  • Load balancing
  • Auto SSL
  • Edge caching
  • Basic WAF rules
  • Prometheus metrics
  • Community support
Enterprise
Custom
  • Everything in Community
  • Multi-region clustering
  • Advanced WAF rules
  • Custom integrations
  • SLA guarantee
  • Dedicated support
  • Professional services

Ready to Build Your Edge Network?

Join developers using WSL Proxy to deliver fast, secure, and reliable applications at the edge.

Star on GitHub Read the Docs