import (
	"github.com/Danny-Dasilva/CycleTLS/cycletls"
	http "github.com/Danny-Dasilva/fhttp" // note this is a drop-in replacement for net/http
)
func main() { 	ja3 := "771,52393-52392-52244-52243-49195-49199-49196-49200-49171-49172-156-157-47-53-10,65281-0-23-35-13-5-18-16-30032-11-10,29-23-24,0" 	ua := "Chrome Version 57.0.2987.110 (64-bit) Linux"
cycleClient := &http.Client{ 		Transport:     cycletls.NewTransport(ja3, ua), 	 }
resp, err := cycleClient.Get("https://tls.peet.ws/") 	... }

There are two simple ways to interface with cookies

Javascript Simple Cookie Configuration

const initCycleTLS = require("cycletls");
(async () => {
  // Initiate cycleTLS
  const cycleTLS = await initCycleTLS();
  const response = await cycleTLS("https://httpbin.org/cookies", {
	cookies: {
	  cookie1: "value1",
	  cookie2: "value2",
	},
  });
  
  const data = await response.json();
  console.log(data);
  /* Expected
  {
	"cookies": {
	  "cookie1": "value1",
	  "cookie2": "value2"
	}
  }
  */
  await cycleTLS.exit();
})();

In this simple example you can set the cookie name and value within an object

Javascript Complex Cookie Configuration

If you wish to have more fine grained control over cookie parameters you have access to the full underlying Go struct

here are the following values you can set

export interface Cookie {
  name: string;
  value: string;
  path?: string;
  domain?: string;
  expires?: string;
  rawExpires?: string;
  maxAge?: number;
  secure?: boolean;
  httpOnly?: boolean;
  sameSite?: string;
  unparsed?: string;
}

you can use them in a request as follows

const initCycleTLS = require("cycletls");
(async () => {
  // Initiate cycleTLS
  const cycleTLS = await initCycleTLS();
  const complexCookies = [
	{
	  name: "cookie1",
	  value: "value1",
	  domain: "httpbin.org",
	},
	{
	  name: "cookie2",
	  value: "value2",
	  domain: "httpbin.org",
	},
  ];
const response = await cycleTLS("https://httpbin.org/cookies", { 	cookies: complexCookies,   });
const data = await response.json();   console.log(data);   /* Expected   { 	"cookies": { 	  "cookie1": "value1", 	  "cookie2": "value2" 	}   }   */   await cycleTLS.exit(); })();

Golang Configure Cookies

package main
import ( 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() { 	resp, err := client.Do("https://httpbin.org/cookies", cycletls.Options{ 		Body:      "", 		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", 		UserAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0", 		Cookies: []cycletls.Cookie{{Name: "cookie1", Value: "value1"}, 			{Name: "cookie2", Value: "value2"}}, 	}, "GET") 	if err != nil { 	  log.Print("Request Failed: " + err.Error()) 	} 	log.Println(resp.Body) 	/* Expected 	{ 	  "cookies": { 		"cookie1": "value1",  		"cookie2": "value2" 	  } 	  } 	*/ 	 	// Alternatively if you want access to values within a map 	log.Println(resp.JSONBody()) 	/* Expected 	map[cookies:map[cookie1:value1 cookie2:value2]] 	*/ }

Feel free to open an Issue with a feature request for specific file type support.

CookieJar in JS

const initCycleTLS = require("cycletls");
const tough = require("tough-cookie"); const Cookie = tough.Cookie;
(async () => {   // Initiate cycleTLS and CookieJar   const cycleTLS = await initCycleTLS();   const cookieJar = new tough.CookieJar();
// Capture a set cookie   const firstResponse = await cycleTLS.get( 	"https://httpbin.org/cookies/set?freeform=test", 	{ 	  disableRedirect: true, 	}   );      // Now use the processCookies function to add the cookies from the response headers to the cookie jar   await processCookies( 	firstResponse, 	"https://httpbin.org/cookies/set?freeform=test", 	cookieJar   );   // Now send a second to verify we have our cookies   const secondResponse = await cycleTLS.get("https://httpbin.org/cookies", { 	headers: { 	  cookie: await cookieJar.getCookieString("https://httpbin.org/cookies"), 	},   });      // Verify cookies were set   const data = await secondResponse.json();   console.log(data)   /* Expected   { 	"cookies": { 	  "freeform": "test" 	}   }   */   await cycleTLS.exit(); })();
async function processCookies(response, url, cookieJar) {   if (response.headers["Set-Cookie"] instanceof Array) { 	response.headers["Set-Cookie"].map( 	  async (cookieString) => await cookieJar.setCookie(cookieString, url) 	);   } else { 	await cookieJar.setCookie(response.headers["Set-Cookie"], url);   } }

CookieJar in Golang

package main
import ( 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	"log" 	"net/http/cookiejar" 	"net/url" 	"strings" )
func main() { 	client := cycletls.Init() 	jar, err := cookiejar.New(nil)   if err != nil { 	  log.Fatal(err)   } 	// First request to set cookie 	firstResponse, err := client.Do("https://httpbin.org/cookies/set?a=1&b=2&c=3", cycletls.Options{ 		Body: "", 		Ja3:       "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0", 		UserAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36", 		DisableRedirect: true, 	}, 		 "GET") 	if err != nil { 		log.Fatal(err) 	} 	firstURL, _ := url.Parse(firstResponse.FinalUrl)   jar.SetCookies( firstURL, firstResponse.Cookies)
// Second request to verify cookies, including the cookies from the first response 	secondResponse, err := client.Do("https://httpbin.org/cookies", cycletls.Options{ 	Body: "", 	Ja3:       "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0", 	UserAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36", 	Headers: map[string]string{ 		"Cookie": getHeadersFromJar(jar, firstURL), 	}, 	}, "GET") 	if err != nil { 		log.Fatal(err) 	}
log.Println("Second Response body:", secondResponse.Body) }
func getHeadersFromJar(jar cookiejar.Jar, url url.URL) string { 	cookies := jar.Cookies(url) 	var cookieStrs []string 	for _, cookie := range cookies { 		cookieStrs = append(cookieStrs, cookie.Name+"="+cookie.Value) 	} 	return strings.Join(cookieStrs, "; ") }

Javascript Text form-data

const initCycleTLS = require("cycletls");
const FormData = require('form-data');
(async () => {   const cycleTLS = await initCycleTLS();
const formData = new FormData();   formData.append("key1", "value1");   formData.append("key2", "value2");      const response = await cycleTLS('http://httpbin.org/post', { 	  body: formData, 	  headers: formData.getHeaders(), // Use formData.getHeaders() for proper content-type   }, 'post');
const data = await response.json();   console.log(data);
await cycleTLS.exit(); })();

Javascript File form-data

const initCycleTLS = require("cycletls");
const FormData = require('form-data');
const fs = require('fs');
(async () => {   const cycleTLS = await initCycleTLS();
const formData = new FormData();   const fileStream = fs.createReadStream("../go.mod");   formData.append('file', fileStream);
const response = await cycleTLS('http://httpbin.org/post', { 	  body: formData, 	  headers: formData.getHeaders(), // Use formData.getHeaders() for proper content-type   }, 'post');
const data = await response.json();   console.log(data);
await cycleTLS.exit(); })();

Golang Text form-data

package main
import ( 	"bytes" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	"log" 	"mime/multipart" )
func main() { 	client := cycletls.Init()
// Prepare a buffer to write our multipart form 	var requestBody bytes.Buffer 	multipartWriter := multipart.NewWriter(&requestBody)
// Add form fields 	multipartWriter.WriteField("key1", "value1") 	multipartWriter.WriteField("key2", "value2")
contentType := multipartWriter.FormDataContentType() 	// Close the writer before making the request 	multipartWriter.Close()
response, err := client.Do("http://httpbin.org/post", cycletls.Options{ 		Body: requestBody.String(), 		Headers: map[string]string{ 			"Content-Type": contentType, 		}, 	}, "POST")
if err != nil { 		log.Print("Request Failed: " + err.Error()) 	}
log.Println(response.Body) }

Golang file upload form-data

package main
import ( 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	"bytes" 	"io" 	"log" 	"mime/multipart" 	"os" )
func main() {   client := cycletls.Init()
// Prepare a buffer to write our multipart form   var requestBody bytes.Buffer   multipartWriter := multipart.NewWriter(&requestBody)
// Add a file   fileWriter, err := multipartWriter.CreateFormFile("fieldname", "filename")   if err != nil { 	  log.Fatal("CreateFormFile Error: ", err)   }
// Open the file that you want to upload   file, err := os.Open("path/to/your/file")   if err != nil { 	  log.Fatal("File Open Error: ", err)   }   defer file.Close()
// Copy the file to the multipart writer   _, err = io.Copy(fileWriter, file)   if err != nil { 	  log.Fatal("File Copy Error: ", err)   }
// Close the writer before making the request   contentType := multipartWriter.FormDataContentType()   multipartWriter.Close()
response, err := client.Do("http://httpbin.org/post", cycletls.Options{ 	  Body: requestBody.String(), 	  Headers: map[string]string{ 		  "Content-Type": contentType, 	  },   }, "POST")
if err != nil { 	  log.Print("Request Failed: " + err.Error())   }
log.Println(response.Body) }

If requested encoding helpers can be added to the repo for golang

Javascript application/x-www-form-urlencoded form

const initCycleTLS = require("cycletls");
(async () => {
  const cycleTLS = await initCycleTLS();
const urlEncodedData = new URLSearchParams();   urlEncodedData.append('key1', 'value1');   urlEncodedData.append('key2', 'value2');
const response = await cycleTLS('http://httpbin.org/post', { 	  body: urlEncodedData, 	  headers: { 		  'Content-Type': 'application/x-www-form-urlencoded', 	  },   }, 'post');
const data = await response.json();   console.log(data);
await cycleTLS.exit(); })();

Golang application/x-www-form-urlencoded form

package main

import ( 	"log" 	  "net/url" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() {
client := cycletls.Init()
// Prepare form data 	form := url.Values{} 	form.Add("key1", "value1") 	form.Add("key2", "value2")
response, err := client.Do("http://httpbin.org/post", cycletls.Options{ 		Body: form.Encode(), 		Headers: map[string]string{ 			"Content-Type": "application/x-www-form-urlencoded", 		}, 	}, "POST") 	if err != nil { 		log.Print("Request Failed: " + err.Error()) 	} 	log.Println(response.Body) }

Images and videos with supported Content-Type headers are returned as raw binary data stored in a string format.

Supported Media Types

• image/svg+xml
• image/webp
• image/jpeg
• image/png
• image/gif
• application/pdf
• video/mp4
• video/webm
• video/avi
• video/quicktime

To write them to a file you can use the below methods

Javascript Media Download Example

const initCycleTLS = require("cycletls");
var fs = require("fs");
(async () => {   const cycleTLS = await initCycleTLS();
// Download image using arrayBuffer() - correct method   const jpegImage = await cycleTLS("http://httpbin.org/image/jpeg", { 	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", 	userAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0",   });      const jpegBuffer = await jpegImage.arrayBuffer();   fs.writeFileSync('./images/output.jpeg', Buffer.from(jpegBuffer));   console.log('JPEG image downloaded');
// Download PNG   const pngImage = await cycleTLS("http://httpbin.org/image/png", { 	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", 	userAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0",   });      const pngBuffer = await pngImage.arrayBuffer();   fs.writeFileSync('./images/output.png', Buffer.from(pngBuffer));   console.log('PNG image downloaded');
// Download WebP   const webpImage = await cycleTLS("http://httpbin.org/image/webp", { 	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", 	userAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0",   });      const webpBuffer = await webpImage.arrayBuffer();   fs.writeFileSync('./images/output.webp', Buffer.from(webpBuffer));   console.log('WebP image downloaded');
// Download video   const videoResponse = await cycleTLS("https://sample-videos.com/zip/10/mp4/SampleVideo360x2401mb.mp4", { 	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", 	userAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0",   });      const videoBuffer = await videoResponse.arrayBuffer();   fs.writeFileSync('./videos/sample_video.mp4', Buffer.from(videoBuffer));   console.log('Video downloaded');
await cycleTLS.exit(); })();

Streaming Binary Data Example

For large files or real-time binary streaming:

const initCycleTLS = require("cycletls");
var fs = require("fs");
(async () => {   const cycleTLS = await initCycleTLS();
// Stream large video file   const response = await cycleTLS("https://sample-videos.com/zip/25/mp4/SampleVideo1280x7205mb.mp4", { 	responseType: 'stream', 	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", 	userAgent: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0",   });
const stream = response.data;   const writeStream = fs.createWriteStream('./videos/large_video.mp4');
let totalSize = 0;      stream.on('data', (chunk) => { 	totalSize += chunk.length; 	console.log(Downloaded ${totalSize} bytes); 	writeStream.write(chunk);   });
stream.on('end', () => { 	writeStream.end(); 	console.log(Stream complete. Total size: ${totalSize} bytes); 	await cycleTLS.exit();   });
stream.on('error', (error) => { 	console.error('Stream error:', error); 	writeStream.end(); 	await cycleTLS.exit();   }); })();

Golang Media Download Example

package main
import ( 	"log" 	"os" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func writeMedia(filepath string, data string) error { 	// Convert string body to bytes (raw binary data) 	bodyBytes := []byte(data) 	 	f, err := os.Create(filepath) 	if err != nil { 		return err 	} 	defer f.Close() 	 	if _, err := f.Write(bodyBytes); err != nil { 		return err 	} 	 	return f.Sync() }
func main() { 	client := cycletls.Init() 	defer client.Close() 	 	// Download image 	response, err := client.Do("http://httpbin.org/image/jpeg", cycletls.Options{ 	  Body:      "", 	  Ja3:       "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-21,29-23-24,0", 	  UserAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36", 	}, "GET") 	 	if err != nil { 		log.Fatal("Image download failed: ", err) 	} 	 	if err := writeMedia("test.jpeg", response.Body); err != nil { 		log.Fatal("Image write failed: ", err) 	} 	log.Println("Image downloaded successfully") 	 	// Download video 	videoResponse, err := client.Do("https://sample-videos.com/zip/10/mp4/SampleVideo360x2401mb.mp4", cycletls.Options{ 	  Body:      "", 	  Ja3:       "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-21,29-23-24,0", 	  UserAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36", 	}, "GET") 	 	if err != nil { 		log.Fatal("Video download failed: ", err) 	} 	 	if err := writeMedia("sample_video.mp4", videoResponse.Body); err != nil { 		log.Fatal("Video write failed: ", err) 	} 	log.Println("Video downloaded successfully") }

Additional file type support is planned.

Feel free to open an Issue with a feature request for specific file type support.

Connection reuse allows you to reuse TLS connections across multiple requests to the same host, reducing handshake overhead and improving performance.

Golang Connection Reuse

package main
import ( 	"log" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() { 	// Initialize without worker pool for better connection management 	client := cycletls.Init(false) 	defer client.Close()
// Enable connection reuse in the options 	options := cycletls.Options{ 		Ja3:                   "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0", 		UserAgent:             "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36", 		EnableConnectionReuse: true, // Enable connection reuse 	}
// First request - establishes connection 	resp1, err := client.Do("https://httpbin.org/get", options, "GET") 	if err != nil { 		log.Fatal("First request failed: ", err) 	} 	log.Println("First request status:", resp1.Status)
// Second request - reuses connection 	resp2, err := client.Do("https://httpbin.org/headers", options, "GET") 	if err != nil { 		log.Fatal("Second request failed: ", err) 	} 	log.Println("Second request status:", resp2.Status)
// Connection is reused for requests to the same host }

CycleTLS now supports HTTP/3 over QUIC protocol with custom QUIC fingerprinting.

Golang HTTP/3 Basic Usage

package main
import ( 	"log" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() { 	client := cycletls.Init() 	defer client.Close()
// Force HTTP/3 	response, err := client.Do("https://cloudflare-quic.com/", cycletls.Options{ 		ForceHTTP3:         true, 		UserAgent:          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", 		InsecureSkipVerify: true, 	}, "GET")
if err != nil { 		log.Fatal("Request failed: ", err) 	}
log.Println("Response over HTTP/3:", response.Status) }

Golang QUIC Fingerprinting

package main
import ( 	"log" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() { 	client := cycletls.Init() 	defer client.Close()
// Custom QUIC fingerprint 	quicFingerprint := "16030106f2010006ee03039a2b98d81139db0e128ea09eff6874549c219b543fb6dbaa7e4dbfe9e31602c620ce04c4026f019442affade7fed8ba66e022e186f77f1c670fd992f33c0143f120020aaaa130113021303c02bc02fc02cc030cca9cca8c013c014009c009d002f0035010006851a1a00000010000e000c02683208687474702f312e31002b000706dada03040303..."
response, err := client.Do("https://cloudflare-quic.com/", cycletls.Options{ 		QUICFingerprint:    quicFingerprint, 		ForceHTTP3:         true, 		UserAgent:          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", 		InsecureSkipVerify: true, 	}, "GET")
if err != nil { 		log.Fatal("Request failed: ", err) 	}
log.Println("Response with QUIC fingerprint:", response.Status) }

Golang HTTP/3 Transport Direct Usage

package main
import ( 	"crypto/tls" 	"log" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	http "github.com/Danny-Dasilva/fhttp" )
func main() { 	// Create TLS config 	tlsConfig := &tls.Config{ 		InsecureSkipVerify: true, 	}
// Create HTTP/3 transport 	transport := cycletls.NewHTTP3Transport(tlsConfig)
// Create request 	req, err := http.NewRequest("GET", "https://cloudflare-quic.com/", nil) 	if err != nil { 		log.Fatal("Failed to create request: ", err) 	}
// Send request 	resp, err := transport.RoundTrip(req) 	if err != nil { 		log.Fatal("Request failed: ", err) 	} 	defer resp.Body.Close()
log.Println("Direct HTTP/3 response:", resp.Status) }

CycleTLS provides a WebSocket client that supports custom TLS fingerprinting.

JavaScript WebSocket Example

const initCycleTLS = require('cycletls');
(async () => {   const cycleTLS = await initCycleTLS();
// WebSocket connection with TLS fingerprinting   const wsResponse = await cycleTLS.ws('wss://echo.websocket.org', { 	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', 	userAgent: 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0', 	headers: { 	  'Sec-WebSocket-Protocol': 'echo-protocol' 	}   });
// Check connection status   if (wsResponse.status === 101) { 	console.log('WebSocket upgrade successful'); 	console.log('Response headers:', wsResponse.headers);   }
await cycleTLS.exit(); })();

Golang WebSocket Example

package main
import ( 	"log" 	"net/http" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	"github.com/gorilla/websocket" 	utls "github.com/refraction-networking/utls" )
func main() { 	// Create TLS config 	tlsConfig := &utls.Config{ 		InsecureSkipVerify: true, 	}
// Create headers 	headers := make(http.Header) 	headers.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36")
// Create WebSocket client 	wsClient := cycletls.NewWebSocketClient(tlsConfig, headers)
// Connect to WebSocket server 	conn, resp, err := wsClient.Connect("wss://echo.websocket.org/") 	if err != nil { 		log.Fatal("WebSocket connection failed: ", err) 	} 	defer conn.Close()
log.Println("WebSocket connected, status:", resp.StatusCode)
// Send message 	testMessage := "Hello, WebSocket!" 	if err := conn.WriteMessage(websocket.TextMessage, []byte(testMessage)); err != nil { 		log.Fatal("Failed to send message: ", err) 	}
// Read response 	messageType, message, err := conn.ReadMessage() 	if err != nil { 		log.Fatal("Failed to read message: ", err) 	}
log.Printf("Received message type %d: %s\n", messageType, string(message)) }

Golang WebSocket Response Wrapper

package main
import ( 	"log" 	"net/http" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	"github.com/gorilla/websocket" 	utls "github.com/refraction-networking/utls" )
func main() { 	// Setup WebSocket client 	tlsConfig := &utls.Config{ 		InsecureSkipVerify: true, 	}
headers := make(http.Header) 	headers.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
wsClient := cycletls.NewWebSocketClient(tlsConfig, headers)
// Connect 	conn, _, err := wsClient.Connect("wss://echo.websocket.org/") 	if err != nil { 		log.Fatal("Connection failed: ", err) 	}
// Create response wrapper 	wsResponse := &cycletls.WebSocketResponse{ 		Conn: conn, 	} 	defer wsResponse.Close()
// Send message using wrapper 	if err := wsResponse.Send(websocket.TextMessage, []byte("Hello!")); err != nil { 		log.Fatal("Send failed: ", err) 	}
// Receive message using wrapper 	messageType, message, err := wsResponse.Receive() 	if err != nil { 		log.Fatal("Receive failed: ", err) 	}
log.Printf("Received: %s (type: %d) ", string(message), messageType) }

CycleTLS supports Server-Sent Events for real-time data streaming from servers.

JavaScript SSE Example

const initCycleTLS = require('cycletls');
(async () => {   const cycleTLS = await initCycleTLS();
// SSE connection with TLS fingerprinting   const sseResponse = await cycleTLS.sse('https://example.com/events', { 	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', 	userAgent: 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0', 	headers: { 	  'Accept': 'text/event-stream', 	  'Cache-Control': 'no-cache' 	}   });
// Parse real-time events   const eventData = await sseResponse.text();   console.log('SSE events:', eventData);
await cycleTLS.exit(); })();

JavaScript SSE with Streaming

const initCycleTLS = require('cycletls');
(async () => {   const cycleTLS = await initCycleTLS();
// SSE with streaming for real-time processing   const response = await cycleTLS.get('https://example.com/events', { 	responseType: 'stream', 	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', 	userAgent: 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:87.0) Gecko/20100101 Firefox/87.0', 	headers: { 	  'Accept': 'text/event-stream', 	  'Cache-Control': 'no-cache' 	}   });
// Process SSE stream in real-time   const stream = response.data;   let buffer = '';
stream.on('data', (chunk) => { 	buffer += chunk.toString(); 	const lines = buffer.split(' '); 	 	// Process complete lines, keep incomplete line in buffer 	buffer = lines.pop() || ''; 	 	for (const line of lines) { 	  if (line.startsWith('data:')) { 		const eventData = line.substring(5).trim(); 		console.log('Event data:', eventData); 	  } else if (line.startsWith('event:')) { 		const eventType = line.substring(6).trim(); 		console.log('Event type:', eventType); 	  } 	}   });
stream.on('end', () => { 	console.log('SSE stream ended'); 	await cycleTLS.exit();   });
stream.on('error', (error) => { 	console.error('SSE stream error:', error); 	await cycleTLS.exit();   }); })();

Golang SSE Client Example

package main
import ( 	"context" 	"fmt" 	"log" 	"time" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" 	fhttp "github.com/Danny-Dasilva/fhttp" )
func main() { 	// Create HTTP client 	httpClient := &fhttp.Client{ 		Timeout: 30 * time.Second, 	}
// Create headers 	headers := make(fhttp.Header) 	headers.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36") 	headers.Set("Accept", "text/event-stream")
// Create SSE client 	sseClient := cycletls.NewSSEClient(httpClient, headers)
// Connect to SSE server with timeout 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 	defer cancel()
sseResp, err := sseClient.Connect(ctx, "http://localhost:3333/events") 	if err != nil { 		log.Fatal("SSE connection failed: ", err) 	} 	defer sseResp.Close()
// Read events 	eventCount := 0 	for eventCount < 5 { 		event, err := sseResp.NextEvent() 		if err != nil { 			log.Printf("Error reading event: %v\n", err) 			break 		} 		 		if event != nil { 			eventCount++ 			fmt.Printf("Event #%d:\n", eventCount) 			fmt.Printf("  Type: %s\n", event.Event) 			fmt.Printf("  Data: %s\n", event.Data) 			fmt.Printf("  ID: %s\n", event.ID) 		} 	} }

Golang SSE with Browser Configuration

package main
import ( 	"context" 	"fmt" 	"log" 	"time" 	"github.com/Danny-Dasilva/CycleTLS/cycletls" )
func main() { 	// Create browser configuration with TLS fingerprinting 	browser := cycletls.Browser{ 		UserAgent:          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10157) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", 		JA3:                "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0", 		InsecureSkipVerify: true, 	}
// Connect to SSE endpoint with timeout 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) 	defer cancel()
response, err := browser.SSEConnect(ctx, "http://127.0.0.1:3333/events") 	if err != nil { 		log.Fatal("SSE connection failed: ", err) 	} 	defer response.Close()
// Process events with detailed parsing 	for { 		event, err := response.NextEvent() 		if err != nil { 			log.Printf("Event stream ended: %v\n", err) 			break 		} 		 		if event != nil && event.Data != "" { 			fmt.Printf("Event Type: %s\n", event.Event) 			fmt.Printf("Event ID: %s\n", event.ID) 			fmt.Printf("Event Data: %s\n", event.Data) 			 			// Break after receiving specific event 			if event.Data == "done" { 				break 			} 		} 	} }

Browser.SSEConnect Method

The Browser.SSEConnect method provides SSE connections with TLS fingerprinting support:

type Browser struct {
	UserAgent          string
	JA3                string
	JA4r               string
	HTTP2Fingerprint   string
	QUICFingerprint    string
	InsecureSkipVerify bool
	ForceHTTP1         bool
	ForceHTTP3         bool
}
// SSEConnect establishes an SSE connection with browser fingerprinting func (b Browser) SSEConnect(ctx context.Context, url string) (SSEResponse, error)

SSE Event Structure

type SSEEvent struct {
	ID    string  // Event ID from server
	Event string  // Event type (custom event names)
	Data  string  // Event data payload
	Retry int64   // Reconnection time in milliseconds
}

Note: Pass ja4r (raw format) to configure fingerprints. JA4 hashes are for observation only.

JA4R is th