Keep-Alive

10-second Keep-Alive example code.

Background

Reduce latency by reusing HTTP connections instead of establishing new connections for each request; Supports HTTP/1.1 persistent connections (keep-alive). This eliminates the TCP and TLS handshake overhead for each request, significantly reducing latency for high-frequency trading.

You need to perform a keep-alive operation on a URL by sending an OPTIONS request to check the service status. The given URL is: http://booster-sg.zan.top, a status code of 200 indicates normal operation.

Quick Start

Endpoint

# Test connection
curl --request OPTIONS --url 'http://booster-sg.zan.top'

# Expected response header status: 200

Expected Response Headers

HTTP/1.1 200 OK
Date: Tue, 14 Apr 2026 07:05:55 GMT
Connection: keep-alive
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: POST,GET,OPTIONS
Access-Control-Max-Age: 600
Allow: GET,POST,PUT,DELETE

Key Parameters

Parameter	Value	Description
Idle timeout	15 seconds	Connection idle timeout, recommend pinging every 10s
Max requests/connection	1000	Maximum requests per connection, reconnect after limit
Ping interval	10 seconds	Recommended keep-alive interval (< 10s timeout)

Performance Comparison

Scenario	Without Keep-Alive	With Keep-Alive
TCP handshake	~1 RTT	Reuse connection
TLS handshake	~2 RTT	Reuse session
Total latency	~50-150ms	~0ms
Use case	Low-frequency requests	High-frequency trading/arbitrage

📘
Note:
Below are simple example code implementations for 10-second keep-alive using Rust, TypeScript, and Python.

Code Examples

Rust Implementation (Simplest Version)

Request Example

use reqwest::Client;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let url = "http://booster-sg.zan.top";
    let client = Client::new();
    let mut count = 1;

    println!("Starting 10-second keep-alive monitoring: {}", url);

    loop {
        match client.request(reqwest::Method::OPTIONS, url).send().await {
            Ok(resp) => {
                if resp.status() == 200 {
                    println!("[{}] ✓ Success - Status code: 200", count);
                } else {
                    println!("[{}] ⚠ Warning - Status code: {}", count, resp.status());
                }
            }
            Err(e) => {
                println!("[{}] ✗ Failed - Error: {}", count, e);
            }
        }

        count += 1;
        tokio::time::sleep(Duration::from_secs(10)).await;
    }
}

Dependencies

[dependencies]
reqwest = "0.11"
tokio = { version = "1.0", features = ["full"] }

TypeScript Implementation (Simplest Version)

Request Example

import axios from 'axios';

const url = 'http://booster-sg.zan.top';
let count = 1;

console.log(`Starting 10-second keep-alive monitoring: ${url}`);

setInterval(async () => {
    try {
        const response = await axios({
            method: 'OPTIONS',
            url: url,
            timeout: 5000,
        });
        
        if (response.status === 200) {
            console.log(`[${count}] ✓ Success - Status code: 200`);
        } else {
            console.log(`[${count}] ⚠ Warning - Status code: ${response.status}`);
        }
    } catch (error: any) {
        console.log(`[${count}] ✗ Failed - Error: ${error.message}`);
    }
    
    count++;
}, 10000);

Dependencies

{
  "dependencies": {
    "axios": "^1.6.0"
  }
}

Python Implementation

Request Example

import requests
import time

url = 'http://booster-sg.zan.top'
count = 1

print(f'Starting 10-second keep-alive monitoring: {url}')

while True:
    try:
        response = requests.options(url, timeout=5)
        
        if response.status_code == 200:
            print(f'[{count}] ✓ Success - Status code: 200')
        else:
            print(f'[{count}] ⚠ Warning - Status code: {response.status_code}')
    except Exception as e:
        print(f'[{count}] ✗ Failed - Error: {e}')
    
    count += 1
    time.sleep(10)

Dependencies

requests>=2.31.0

Updated about 4 hours ago