Performance Issue in CycleTLS with `Node.js` Compared to `Go`

[NabiKAZ]

Description

I noticed a strange slowdown in CycleTLS performance!

I was using Node.js at first and thought the issue was due to my proxies being slow — which seemed normal.
But later, when I tried the Go version, I realized it was much faster.

I know that CycleTLS uses a WebSocket connection between Node.js and Go internally,
but even considering that, such a significant delay shouldn’t exist.

At first, I thought maybe the problem was with my target site,
but I tested it with Google and got the same results.
The thing is, when sites like Google are fast, this difference might not be noticeable.
But when you test with a proxy that has, say, a 5-second delay,
the difference becomes very clear.

I wrote identical code for both Node.js and Go and tested them under the same conditions.
Pay attention to the duration of each request — I highlighted it in blue.
I used a relatively slow proxy.

• On my target site, in Go, the first request takes 4921ms (including setup), and the following ones are around 1500ms.
• But in Node.js, the first request takes 5439ms, and all the following requests stay around the same range!
  It seems every request includes the initial setup, which is inefficient.
  → That’s roughly a 260% performance drop!

A similar pattern occurs with Google:

• In Go, the first request is 1003ms and the rest are about 600ms,
• But in Node.js, all of them stay around 1000ms — again including the setup time.
  → That’s about a 60% slowdown here as well.

This issue becomes particularly important when using an infinite loop to continuously check a website.

Attached are screenshots showing the request timings for both Node.js and Go.

Issue Type

Bug

Operating System

Windows 10

Node Version

Node 22.x

Golang Version

Other

Relevant Log Output

[NabiKAZ]

I realized that to compensate for the delay in persistent connections, the enableConnectionReuse method can somewhat improve performance, but there’s still an issue with parallel connections.
To test this, I wrote a script to examine the behavior under different conditions:

// x.com/NabiKAZ
// github.com/NabiKAZ

import initCycleTLS from 'cycletls';
import chalk from 'chalk';

// ========== Configuration ==========
const ENABLE_CONNECTION_REUSE = true; // Toggle connection reuse for testing
const IS_CONCURRENT = true; // true: Concurrent mode | false: Sequential mode
const DELAY_BETWEEN_REQUESTS_MS = 100; // Delay between requests in milliseconds
const TEST_URL = 'https://www.google.com';
const NUM_INSTANCES = 5; // Number of CycleTLS instances (different ports)
const NUM_REQUESTS_PER_INSTANCE = 2; // Number of requests each instance will make
// ===================================

// Helper function: Delay
const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// Logging function with timestamp (millisecond precision)
function log(message, color = 'white') {
    const now = new Date();
    const timestamp = `${now.toLocaleDateString('en-US')} ${now.toLocaleTimeString('en-US', { hour12: false })}.${String(now.getMilliseconds()).padStart(3, '0')}`;
    const coloredMessage = color !== 'white' ? chalk[color](message) : message;
    console.log(`${chalk.dim(`[${timestamp}]`)} ${coloredMessage}`);
}

// Display configuration status
log('========================================', 'yellow');
log('  CycleTLS Connection Reuse Test', 'yellow');
log('========================================', 'yellow');
log(`Connection Reuse: ${ENABLE_CONNECTION_REUSE ? chalk.green('ENABLED ✓') : chalk.red('DISABLED ✗')}`, 'white');
log(`Execution Mode: ${IS_CONCURRENT ? chalk.cyan('Concurrent') : chalk.magenta('Sequential')}`, 'white');
log(`Delay Between Requests: ${DELAY_BETWEEN_REQUESTS_MS}ms`, 'white');
log(`Test URL: ${TEST_URL}`, 'white');
log(`Instances: ${NUM_INSTANCES}`, 'white');
log(`Requests per Instance: ${NUM_REQUESTS_PER_INSTANCE}`, 'white');
log(`Mode: ${IS_CONCURRENT ? chalk.magenta('Concurrent') : chalk.blue('Sequential')}`, 'white');
log('========================================\n', 'yellow');

// Array to hold all CycleTLS instances
const instances = [];

// Initialize instances outside the loop
log('Initializing CycleTLS instances...', 'cyan');
for (let i = 0; i < NUM_INSTANCES; i++) {
    const port = 9119 + i; // Ports: 9119, 9120, ..., up to NUM_INSTANCES
    const cycleTLS = await initCycleTLS({ port: port, timeout: 30000 });
    instances.push(cycleTLS);
}
log(`✅ ${NUM_INSTANCES} instances initialized\n`, 'green');

// Function to perform a single request
async function performRequest(instanceIndex, requestIndex, cycleTLS) {
    const instancePort = 9119 + instanceIndex;
    log(`Instance ${instanceIndex + 1} (Port ${instancePort}) - Request ${requestIndex + 1}:`, 'cyan');

    // Start time
    const startTime = performance.now();

    // Send request
    const response = await cycleTLS(TEST_URL, {
        // JA3 token to send with request
        ja3: '771,4865-4867-4866-49195-49199-52393-52392-49196-49200-49162-49161-49171-49172-51-57-47-53-10,0-23-65281-10-11-35-16-5-51-43-13-45-28-21,29-23-24-25-256-257,0',
        // JA4R token for enhanced fingerprinting (raw format)
        ja4r: 't13d1516h2_002f,0035,009c,009d,1301,1302,1303,c013,c014,c02b,c02c,c02f,c030,cca8,cca9_0000,0005,000a,000b,000d,0012,0017,001b,0023,002b,002d,0033,44cd,fe0d,ff01_0403,0804,0401,0503,0805,0501,0806,0601',
        // User agent for request
        userAgent: 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0',
        // Proxy to send request through (supports http, socks4, socks5, socks5h)
        // proxy: 'http://username:password@hostname.com:443',
        // Amount of seconds before request timeout (default: 7)
        // timeout: 2,
        // Toggle if CycleTLS should follow redirects
        disableRedirect: true,
        // Custom header order to send with request (This value will overwrite default header order)
        headerOrder: ["cache-control", "connection", "host"],
        // Toggle if CycleTLS should skip verify certificate
        insecureSkipVerify: false,
        // Forces CycleTLS to do a http1 handshake
        forceHTTP1: false,
        // Forces HTTP/3 protocol
        forceHTTP3: false,
        // Enable connection reuse across requests
        enableConnectionReuse: ENABLE_CONNECTION_REUSE,
        // HTTP/2 fingerprint
        http2Fingerprint: '1:65536;4:131072;5:16384|12517377|3:0:0:201,5:0:0:101,7:0:0:1,9:0:7:1,11:0:3:1,13:0:0:241|m,p,a,s',
        // QUIC fingerprint for HTTP/3
        // quicFingerprint: '16030106f2010006ee03039a2b98d81139db0e128ea09eff...',
        // JA4H HTTP client fingerprint
        ja4h: 'ge11_73a4f1e_8b3fce7',
    }, 'get');

    // End time
    const endTime = performance.now();

    // Calculate execution time (in milliseconds)
    const executionTime = endTime - startTime;

    // Display execution time and status with instance and request info
    const statusColor = response.status === 200 ? 'green' : 'red';
    log(`  ↳ Instance ${instanceIndex + 1}, Request ${requestIndex + 1}: ${executionTime.toFixed(2)} ms, Status: ${response.status}`, statusColor);
    
    // Return execution time with instance and request info
    return { instanceIndex, requestIndex, executionTime };
}

// Run requests based on mode
const results = [];
if (IS_CONCURRENT) {
    // Concurrent execution for all instances and their requests (default)
    const promises = [];
    for (let i = 0; i < NUM_INSTANCES; i++) {
        for (let j = 0; j < NUM_REQUESTS_PER_INSTANCE; j++) {
            // Add a small delay between each request to avoid overwhelming the server
            promises.push(
                (async () => {
                    if (DELAY_BETWEEN_REQUESTS_MS > 0) {
                        await delay(DELAY_BETWEEN_REQUESTS_MS * (i * NUM_REQUESTS_PER_INSTANCE + j));
                    }
                    return await performRequest(i, j, instances[i]);
                })()
            );
        }
    }
    const allResults = await Promise.all(promises);
    results.push(...allResults);
} else {
    // Fully sequential execution: one instance at a time, one request at a time
    for (let i = 0; i < NUM_INSTANCES; i++) {
        for (let j = 0; j < NUM_REQUESTS_PER_INSTANCE; j++) {
            const result = await performRequest(i, j, instances[i]);
            results.push(result);
            
            // Add delay between sequential requests if configured
            if (DELAY_BETWEEN_REQUESTS_MS > 0 && (i < NUM_INSTANCES - 1 || j < NUM_REQUESTS_PER_INSTANCE - 1)) {
                await delay(DELAY_BETWEEN_REQUESTS_MS);
            }
        }
    }
}

// Group results by instance
const instanceStats = {};
for (const result of results) {
    const instanceKey = result.instanceIndex;
    if (!instanceStats[instanceKey]) {
        instanceStats[instanceKey] = [];
    }
    instanceStats[instanceKey].push(result.executionTime);
}

// Display statistics per instance
log('\n=== Statistics Per Instance ===', 'yellow');
for (let i = 0; i < NUM_INSTANCES; i++) {
    const times = instanceStats[i] || [];
    if (times.length === 0) continue;
    
    const instancePort = 9119 + i;
    const totalTime = times.reduce((sum, time) => sum + time, 0);
    const avgTime = totalTime / times.length;
    const minTime = Math.min(...times);
    const maxTime = Math.max(...times);
    
    log(`\nInstance ${i + 1} (Port ${instancePort}):`, 'cyan');
    log(`  Requests: ${times.length}`, 'white');
    log(`  Average: ${avgTime.toFixed(2)} ms`, 'blue');
    log(`  Minimum: ${minTime.toFixed(2)} ms`, 'green');
    log(`  Maximum: ${maxTime.toFixed(2)} ms`, 'magenta');
}

// Overall statistics
const allTimes = results.map(r => r.executionTime);
const overallTotal = allTimes.reduce((sum, time) => sum + time, 0);
const overallAvg = overallTotal / allTimes.length;
const overallMin = Math.min(...allTimes);
const overallMax = Math.max(...allTimes);

log('\n=== Overall Statistics ===', 'yellow');
log(`Total Requests: ${allTimes.length}`, 'white');
log(`Average: ${overallAvg.toFixed(2)} ms`, 'blue');
log(`Minimum: ${overallMin.toFixed(2)} ms`, 'green');
log(`Maximum: ${overallMax.toFixed(2)} ms`, 'magenta');

// Cleanup: Exit all CycleTLS instances
log('\nCleaning up CycleTLS instances...', 'gray');
for (const cycleTLS of instances) {
    await cycleTLS.exit();
}
log('✅ All instances closed successfully', 'green');

In the sequential mode with a single connection and reuse disabled, you can see the minimum, maximum, and average execution times as a baseline:

Now we enable reuse, and you can see that performance improves starting from the second request onward:

Next, we test the parallel mode. Since there’s a chance of interference, each instance runs on a separate port. We disable reuse, and the delay is noticeable:
2 instances, 5 requests for each.

Now, considering that enabling reuse worked well in sequential mode, and that our instances run on separate ports, we’d expect parallel mode to reach the ideal and expected performance. But suddenly—

Boom! Strange errors start appearing!

Error Processing Request (please open an issue https://github.com/Danny-Dasilva/CycleTLS/issues/new/choose) -> panic: dialTLS returned no error when determining cached transports

goroutine 34 [running]:

Error Processing Request (please open an issue https://github.com/Danny-Dasilva/CycleTLS/issues/new/choose) -> github.com/Danny-Dasilva/CycleTLS/cycletls.(*roundTripper).getTransport(0xc00022d040, 0xc000298360, {0xc00029a078, 0x12})
        /home/runner/work/CycleTLS/CycleTLS/cycletls/roundtripper.go:186 +0x285
github.com/Danny-Dasilva/CycleTLS/cycletls.(*roundTripper).RoundTrip(0xc00022d040, 0xc000298360)
        /home/runner/work/CycleTLS/CycleTLS/cycletls/roundtripper.go:157 +0x7bf
github.com/Danny-Dasilva/fhttp.send(0xc000298240, {0xfbf0e0, 0xc00022d040}, {0x4c099d4d03175b01?, 0xec1a0453ca74866?, 0x1415ee0?})
        /home/runner/go/pkg/mod/github.com/!danny-!dasilva/fhttp@v0.0.0-20240217042913-eeeb0b347ce1/client.go:251 +0x542
github.com/Danny-Dasilva/fhttp.(*Client).send(0xc0002bc188, 0xc000298240, {0x0?, 0x0?, 0x1415ee0?})
        /home/runner/go/pkg/mod/github.com/!danny-!dasilva/fhttp@v0.0.0-20240217042913-eeeb0b347ce1/client.go:175 +0x91
github.com/Danny-Dasilva/fhttp.(*Client).do(0xc0002bc188, 0xc000298240)
        /home/runner/go/pkg/mod/github.com/!danny-!dasilva/fhttp@v0.0.0-20240217042913-eeeb0b347ce1/client.go:717 +0x89c
github.com/Danny-Dasilva/fhttp.(*Client).Do(...)
        /home/runner/go/pkg/mod/github.com/!danny-!dasilva/fhttp@v0.0.0-20240217042913-eeeb0b347ce1/client.go:585
github.com/Danny-Dasilva/CycleTLS/cycletls.dispatcherAsync({0xc000298240, {{0xfbf0e0, 0xc00022d040}, 0xf27a38, {0x0, 0x0}, 0x37e11d600}, {{0xc0002960a0, 0x41}, {{0xc00029a060, ...}, ...}}, ...}, ...)
        /home/runner/work/CycleTLS/CycleTLS/cycletls/index.go:612 +0x21e
created by github.com/Danny-Dasilva/CycleTLS/cycletls.readProcess in goroutine 9
        /home/runner/work/CycleTLS/CycleTLS/cycletls/index.go:1198 +0x65

[11/1/2025 18:47:09.478] Instance 1 (Port 9119) - Request 5:
Error Processing Request (please open an issue https://github.com/Danny-Dasilva/CycleTLS/issues/new/choose) -> 2025/11/01 18:47:09 listen tcp :9119: bind: Only one usage of each socket address (protocol/network address/port) is normally permitted.

As a result, this experiment failed! :-(

[NabiKAZ]

I recently came across the project Sahil1337/node-tls-client, which allows TLS fingerprint modification using external libraries and DLLs.
And it was also successful in bypassing Cloudflare.

I tried to make a comparison between it and CycleTLS.

As we observed in previous experiments, CycleTLS by default does not use connection keep-alive or caching, and the average duration across all connections is around 1600 ms.
However, in the lower chart showing node-tls-client, the first request takes about 1300 ms, and subsequent requests average around 350 ms, which is excellent — clearly showing that it uses keep-alive.

When tested with a slower proxy, CycleTLS consistently shows around 2500 ms, while node-tls-client takes 2300 ms for the first request and averages about 550 ms for subsequent ones — again performing better.

I also suspect that node-tls-client may not suffer from crash issues, since it directly relies on external libraries (.dll, .so, etc.) instead of using a WebSocket-based connection like CycleTLS.
However, this assumption still needs to be verified through practical tests.