tls_client

README

TLS-Client

Preface

This TLS Client is built upon https://github.com/Carcraftz/fhttp and https://github.com/Carcraftz/utls (https://github.com/refraction-networking/utls). Big thanks to all contributors so far. Sadly it seems that the original repositories from Carcraftz are not maintained anymore.

What is TLS Fingerprinting?

Some people think it is enough to change the user-agent header of a request to let the server think that the client requesting a resource is a specific browser. Nowadays this is not enough, because the server might use a technique to detect the client browser which is called TLS Fingerprinting.

Even though this article is about TLS Fingerprinting in NodeJS it well describes the technique in general. https://httptoolkit.tech/blog/tls-fingerprinting-node-js/#how-does-tls-fingerprinting-work

Why is this library needed?

With this library you are able to create a http client implementing an interface which is similar to golangs net/http client interface. This TLS Client allows you to specify the Client (Browser and Version) you want to use, when requesting a server.

Features

• ✅ HTTP/1.1, HTTP/2, HTTP/3 - Full protocol support with automatic negotiation
• ✅ Protocol Racing - Chrome-like "Happy Eyeballs" for HTTP/2 vs HTTP/3
• ✅ TLS Fingerprinting - Mimic Chrome, Firefox, Safari, and other browsers
• ✅ HTTP/3 Fingerprinting - Accurate QUIC/HTTP/3 fingerprints matching real browsers
• ✅ WebSocket Support - Maintain TLS fingerprinting over WebSocket connections
• ✅ Custom Header Ordering - Control the order of HTTP headers
• ✅ Proxy Support - HTTP and SOCKS5 proxies
• ✅ Cookie Jar Management - Built-in cookie handling
• ✅ Certificate Pinning - Enhanced security with custom certificate validation
• ✅ Bandwidth Tracking - Monitor upload/download bandwidth
• ✅ Language Bindings - Use from JavaScript (Node.js), Python, and C# via FFI

Interface

The HTTP Client interface extends the base net/http Client with additional functionality:

type HttpClient interface {
    GetCookies(u *url.URL) []*http.Cookie
    SetCookies(u *url.URL, cookies []*http.Cookie)
    SetCookieJar(jar http.CookieJar)
    GetCookieJar() http.CookieJar
    SetProxy(proxyUrl string) error
    GetProxy() string
    SetFollowRedirect(followRedirect bool)
    GetFollowRedirect() bool
    CloseIdleConnections()
    Do(req *http.Request) (*http.Response, error)
    Get(url string) (resp *http.Response, err error)
    Head(url string) (resp *http.Response, err error)
    Post(url, contentType string, body io.Reader) (resp *http.Response, err error)

    GetBandwidthTracker() bandwidth.BandwidthTracker
    GetDialer() proxy.ContextDialer
    GetTLSDialer() TLSDialerFunc
}

Detailed Documentation

https://bogdanfinn.gitbook.io/open-source-oasis/

Quick Usage Example

package main

import (
	"fmt"
	"io"
	"log"

	http "github.com/bogdanfinn/fhttp"
	tls_client "github.com/bogdanfinn/tls-client"
	"github.com/bogdanfinn/tls-client/profiles"
)

func main() {
	jar := tls_client.NewCookieJar()
	options := []tls_client.HttpClientOption{
		tls_client.WithTimeoutSeconds(30),
		tls_client.WithClientProfile(profiles.Chrome_150),
		tls_client.WithNotFollowRedirects(),
		tls_client.WithCookieJar(jar), // create cookieJar instance and pass it as argument
	}

	client, err := tls_client.NewHttpClient(tls_client.NewNoopLogger(), options...)
	if err != nil {
		log.Println(err)
		return
	}

	req, err := http.NewRequest(http.MethodGet, "https://tls.peet.ws/api/all", nil)
	if err != nil {
		log.Println(err)
		return
	}

	req.Header = http.Header{
		"accept":                    {"*/*"},
		"accept-language":           {"de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7"},
		"user-agent":                {"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36"},
		http.HeaderOrderKey: {
			"accept",
			"accept-language",
			"user-agent",
		},
	}

	resp, err := client.Do(req)
	if err != nil {
		log.Println(err)
		return
	}

	defer resp.Body.Close()

	log.Println(fmt.Sprintf("status code: %d", resp.StatusCode))

	readBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Println(err)
		return
	}

	log.Println(string(readBytes))
}

Questions?

Join my discord support server for free: https://discord.gg/7Ej9eJvHqk No Support in DMs!

Appreciate my work?

Or, if you prefer crypto:

• ETH 0x1Ef18abfE61372e49F08eD24B1055cbDD5d7e0Fc
• BTC bc1qkfqu5xvayqh55gwjtyannvyqzr4cax4eu3k2u6
• ADA addr1qxj5hg5xfq9l5r5ed7av7mzg0gy5xemn64lkna5cuu9e4yt0vk8st6zvmfuqjdz849drd7zgcdky4zrdvm603dzf4dgs5unend
• SOL 7hYfiX4R5bEbggYY2JRZi2a3EdcEzQ6XbgZiHRiRHjau

---

🛡️ Need Antibot Bypass?

TLS fingerprinting alone isn't enough for modern bot protection. Hyper Solutions provides the missing piece - API endpoints that generate valid antibot tokens for:

Akamai • DataDome • Kasada • Incapsula

No browser automation. Just simple API calls that return the exact cookies and headers these systems require.

🚀 Get Your API Key | 📖 Docs | 💬 Discord

---

Powered by

Documentation

Index

• Constants
• Variables
• func GetSpecFactoryFromJa3String(ja3String string, ...) (func() (tls.ClientHelloSpec, error), error)
• func Int64ToInt(x int64) (int, error)
• type BadPinHandlerFunc
• type CandidateCipherSuites
• type CertificatePinner
  • func NewCertificatePinner(certificatePins map[string][]string) (CertificatePinner, error)
• type ContextKeyHeader
• type CookieJar
  • func NewCookieJar(options ...CookieJarOption) CookieJar
• type CookieJarOption
  • func WithAllowEmptyCookies() CookieJarOption
  • func WithDebugLogger() CookieJarOption
  • func WithLogger(logger Logger) CookieJarOption
  • func WithSkipExisting() CookieJarOption
• type HttpClient
  • func NewHttpClient(logger Logger, options ...HttpClientOption) (HttpClient, error)
  • func ProvideDefaultClient(logger Logger) (HttpClient, error)
• type HttpClientOption
  • func WithBandwidthTracker() HttpClientOption
  • func WithCatchPanics() HttpClientOption
  • func WithCertificatePinner(pinner CertificatePinner) HttpClientOption
  • func WithCertificatePinning(certificatePins map[string][]string, handlerFunc BadPinHandlerFunc) HttpClientOption
  • func WithCharlesProxy(host string, port string) HttpClientOption
  • func WithClientProfile(clientProfile profiles.ClientProfile) HttpClientOption
  • func WithConnectHeaders(headers http.Header) HttpClientOption
  • func WithCookieJar(jar http.CookieJar) HttpClientOption
  • func WithCustomRedirectFunc(redirectFunc func(req *http.Request, via []*http.Request) error) HttpClientOption
  • func WithDebug() HttpClientOption
  • func WithDefaultHeaders(defaultHeaders http.Header) HttpClientOption
  • func WithDialContext(dialContext func(ctx context.Context, network, addr string) (net.Conn, error)) HttpClientOption
  • func WithDialer(dialer net.Dialer) HttpClientOption
  • func WithDisableHttp3() HttpClientOption
  • func WithDisableIPV4() HttpClientOption
  • func WithDisableIPV6() HttpClientOption
  • func WithDisableSessionTickets() HttpClientOption
  • func WithForceHttp1() HttpClientOption
  • func WithInsecureSkipVerify() HttpClientOption
  • func WithLocalAddr(localAddr net.TCPAddr) HttpClientOption
  • func WithNotFollowRedirects() HttpClientOption
  • func WithPostHook(hook PostResponseHookFunc) HttpClientOption
  • func WithPreHook(hook PreRequestHookFunc) HttpClientOption
  • func WithProtocolRacing() HttpClientOption
  • func WithProxyDialerFactory(proxyDialerFactory ProxyDialerFactory) HttpClientOption
  • func WithProxyUrl(proxyUrl string) HttpClientOption
  • func WithRandomTLSExtensionOrder() HttpClientOption
  • func WithServerNameOverwrite(serverName string) HttpClientOption
  • func WithTimeout(timeout int) HttpClientOption
  • func WithTimeoutMilliseconds(timeout int) HttpClientOption
  • func WithTimeoutSeconds(timeout int) HttpClientOption
  • func WithTransportOptions(transportOptions *TransportOptions) HttpClientOption
• type Logger
  • func NewDebugLogger(logger Logger) Logger
  • func NewLogger() Logger
  • func NewNoopLogger() Logger
• type PostResponseContext
• type PostResponseHookFunc
• type PreRequestHookFunc
• type ProxyDialerFactory
• type TLSDialerFunc
• type TransportOptions
• type Websocket
  • func NewWebsocket(logger Logger, options ...WebsocketOption) (*Websocket, error)
  • func (w *Websocket) Connect(ctx context.Context) (*websocket.Conn, error)
• type WebsocketOption
  • func WithCookiejar(cookiejar http.CookieJar) WebsocketOption
  • func WithEnableCompression() WebsocketOption
  • func WithHandshakeTimeoutMilliseconds(timeout int) WebsocketOption
  • func WithHeaders(headers http.Header) WebsocketOption
  • func WithReadBufferSize(readBufferSize int) WebsocketOption
  • func WithTlsClient(tlsClient HttpClient) WebsocketOption
  • func WithUrl(url string) WebsocketOption
  • func WithWriteBufferSize(writeBufferSize int) WebsocketOption

Constants

const CHROME_MAX_FIELD_SECTION_SIZE = 262144

Variables

var DefaultBadPinHandler = func(req *http.Request) {
	fmt.Println("this is the default bad pin handler")
}

var DefaultOptions = []HttpClientOption{
	WithTimeoutSeconds(DefaultTimeoutSeconds),
	WithClientProfile(profiles.DefaultClientProfile),
	WithRandomTLSExtensionOrder(),
	WithNotFollowRedirects(),
}

var DefaultTimeoutSeconds = 30

var ErrBadPinDetected = errors.New("bad ssl pin detected")

var ErrContinueHooks = errors.New("continue hooks")

ErrContinueHooks can be returned (or wrapped) by a PreRequestHookFunc to signal that the error should be logged but hook execution should continue to the next hook. By default any error returned from a hook aborts subsequent hooks and the request.

var H2SettingsMap = map[string]http2.SettingID{
	"HEADER_TABLE_SIZE":      http2.SettingHeaderTableSize,
	"ENABLE_PUSH":            http2.SettingEnablePush,
	"MAX_CONCURRENT_STREAMS": http2.SettingMaxConcurrentStreams,
	"INITIAL_WINDOW_SIZE":    http2.SettingInitialWindowSize,
	"MAX_FRAME_SIZE":         http2.SettingMaxFrameSize,
	"MAX_HEADER_LIST_SIZE":   http2.SettingMaxHeaderListSize,
	"UNKNOWN_SETTING_7":      0x7,
	"UNKNOWN_SETTING_8":      0x8,
	"UNKNOWN_SETTING_9":      0x9,
}

var H3SettingsMap = map[string]uint64{
	"QPACK_MAX_TABLE_CAPACITY": 0x1,
	"MAX_FIELD_SECTION_SIZE":   0x6,
	"QPACK_BLOCKED_STREAMS":    0x7,
	"H3_DATAGRAM":              0x33,
}

Functions

func GetSpecFactoryFromJa3String

func GetSpecFactoryFromJa3String(ja3String string, supportedSignatureAlgorithms, supportedDelegatedCredentialsAlgorithms, supportedVersions, keyShareCurves, supportedProtocolsALPN, supportedProtocolsALPS []string, echCandidateCipherSuites []CandidateCipherSuites, candidatePayloads []uint16, certCompressionAlgorithms []string, recordSizeLimit uint16, trustAnchorsPayload string) (func() (tls.ClientHelloSpec, error), error)

func Int64ToInt

func Int64ToInt(x int64) (int, error)

Types

type BadPinHandlerFunc

type BadPinHandlerFunc func(req *http.Request)

type CandidateCipherSuites

type CandidateCipherSuites struct {
	KdfId  string
	AeadId string
}

type CertificatePinner

type CertificatePinner interface {
	Pin(conn *tls.UConn, host string) error
}

func NewCertificatePinner

func NewCertificatePinner(certificatePins map[string][]string) (CertificatePinner, error)

type ContextKeyHeader

type ContextKeyHeader struct{}

Users of context.WithValue should define their own types for keys

type CookieJar

type CookieJar interface {
	http.CookieJar
	GetAllCookies() map[string][]*http.Cookie
}

func NewCookieJar

func NewCookieJar(options ...CookieJarOption) CookieJar

type CookieJarOption

type CookieJarOption func(config *cookieJarConfig)

func WithAllowEmptyCookies

func WithAllowEmptyCookies() CookieJarOption

func WithDebugLogger

func WithDebugLogger() CookieJarOption

func WithLogger

func WithLogger(logger Logger) CookieJarOption

func WithSkipExisting

func WithSkipExisting() CookieJarOption

type HttpClient

type HttpClient interface {
	GetCookies(u *url.URL) []*http.Cookie
	SetCookies(u *url.URL, cookies []*http.Cookie)
	SetCookieJar(jar http.CookieJar)
	GetCookieJar() http.CookieJar
	SetProxy(proxyUrl string) error
	GetProxy() string
	SetFollowRedirect(followRedirect bool)
	GetFollowRedirect() bool
	CloseIdleConnections()
	Do(req *http.Request) (*http.Response, error)
	Get(url string) (resp *http.Response, err error)
	Head(url string) (resp *http.Response, err error)
	Post(url, contentType string, body io.Reader) (resp *http.Response, err error)

	GetBandwidthTracker() bandwidth.BandwidthTracker
	GetDialer() proxy.ContextDialer
	GetTLSDialer() TLSDialerFunc

	AddPreRequestHook(hook PreRequestHookFunc)
	AddPostResponseHook(hook PostResponseHookFunc)
	ResetPreHooks()
	ResetPostHooks()
}

func NewHttpClient

func NewHttpClient(logger Logger, options ...HttpClientOption) (HttpClient, error)

NewHttpClient constructs a new HTTP client with the given logger and client options.

func ProvideDefaultClient

func ProvideDefaultClient(logger Logger) (HttpClient, error)

type HttpClientOption

type HttpClientOption func(config *httpClientConfig)

func WithBandwidthTracker

func WithBandwidthTracker() HttpClientOption

WithBandwidthTracker configures a client to track the bandwidth used by the client.

func WithCatchPanics

func WithCatchPanics() HttpClientOption

WithCatchPanics configures a client to catch all go panics happening during a request and not print the stacktrace.

func WithCertificatePinner

func WithCertificatePinner(pinner CertificatePinner) HttpClientOption

WithCertificatePinner supplies a custom CertificatePinner, used wherever the built-in one is: on the TLS handshake of every HTTP/1.1 and HTTP/2 connection.

It is the escape hatch for validation the built-in SPKI pinner cannot express: checking the peer's subject or SAN entries, refusing issuers that belong to interception tooling, or any other rule that needs to look at the certificate rather than compare a hash. The pinner receives the same *tls.UConn the built-in one does, so conn.ConnectionState() is available to it.

HTTP/3 is not covered. Those transports are built from http3Config and carry their own QUIC TLS stack, which never reaches Pin — this is true of WithCertificatePinning today and is unchanged here. A client that enables protocol racing can therefore complete an h3 connection without either pinner running; covering it would need an interface that is not tied to *tls.UConn. Callers that require the check on every connection should keep HTTP/3 off (WithDisableHttp3).

Takes precedence over WithCertificatePinning; the two are not combined.

func WithCertificatePinning

func WithCertificatePinning(certificatePins map[string][]string, handlerFunc BadPinHandlerFunc) HttpClientOption

WithCertificatePinning enables SSL Pinning for the client and will throw an error if the SSL Pin is not matched. Please refer to https://github.com/tam7t/hpkp/#examples in order to see how to generate pins. The certificatePins are a map with the host as key. You can provide a BadPinHandlerFunc or nil as second argument. This function will be executed once a bad ssl pin is detected. BadPinHandlerFunc has to be defined like this: func(req *http.Request){}

func WithCharlesProxy

func WithCharlesProxy(host string, port string) HttpClientOption

WithCharlesProxy configures the HTTP client to use a local running charles as proxy.

host and port can be empty, then default 127.0.0.1 and port 8888 will be used

func WithClientProfile

func WithClientProfile(clientProfile profiles.ClientProfile) HttpClientOption

WithClientProfile configures a TLS client to use the specified client profile.

func WithConnectHeaders

func WithConnectHeaders(headers http.Header) HttpClientOption

WithConnectHeaders configures a client to use the specified headers for the CONNECT request.

The client writes Host itself and, when no User-Agent is given, Go's own. The headers go out in the order named under http.HeaderOrderKey, spelled either way, and alphabetically when no order is given. Chrome sends three on a CONNECT: Host, Proxy-Connection: keep-alive and User-Agent, in that order.

func WithCookieJar

func WithCookieJar(jar http.CookieJar) HttpClientOption

WithCookieJar configures a HTTP client to use the specified cookie jar.

func WithCustomRedirectFunc

func WithCustomRedirectFunc(redirectFunc func(req *http.Request, via []*http.Request) error) HttpClientOption

WithCustomRedirectFunc configures an HTTP client to use a custom redirect func. The redirect func have to look like that: func(req *http.Request, via []*http.Request) error Please only provide a custom redirect function if you know what you are doing. Check docs on net/http.Client CheckRedirect

func WithDebug

func WithDebug() HttpClientOption

WithDebug configures a client to log debugging information.

func WithDefaultHeaders

func WithDefaultHeaders(defaultHeaders http.Header) HttpClientOption

WithDefaultHeaders configures a TLS client to use a set of default headers if none are specified on the request.

func WithDialContext

func WithDialContext(dialContext func(ctx context.Context, network, addr string) (net.Conn, error)) HttpClientOption

WithDialContext sets a custom dialer for TCP connections, allowing advanced networking (Zero-DNS, socket tagging, DPI bypass).

WARNING: This overrides built-in proxy settings. If you need a proxy, you must handle the CONNECT handshake manually. CHECK: https://github.com/bogdanfinn/tls-client/pull/218#issuecomment-3858171801

func WithDialer

func WithDialer(dialer net.Dialer) HttpClientOption

WithDialer configures an HTTP client to use the specified dialer. This allows the use of a custom DNS resolver

func WithDisableHttp3

func WithDisableHttp3() HttpClientOption

WithDisableHttp3 configures a client to disable HTTP 3 as the used protocol. Will most likely fall back to HTTP 2

func WithDisableIPV4

func WithDisableIPV4() HttpClientOption

WithDisableIPV4 configures a dialer to use tcp6 network argument

func WithDisableIPV6

func WithDisableIPV6() HttpClientOption

WithDisableIPV6 configures a dialer to use tcp4 network argument

func WithDisableSessionTickets

func WithDisableSessionTickets() HttpClientOption

WithDisableSessionTickets configures a client to disable TLS session ticket caching and resumption.

func WithForceHttp1

func WithForceHttp1() HttpClientOption

WithForceHttp1 configures a client to force HTTP/1.1 as the used protocol.

func WithInsecureSkipVerify

func WithInsecureSkipVerify() HttpClientOption

WithInsecureSkipVerify configures a client to skip SSL certificate verification.

func WithLocalAddr

func WithLocalAddr(localAddr net.TCPAddr) HttpClientOption

WithLocalAddr configures an HTTP client to use the specified local address.

func WithNotFollowRedirects

func WithNotFollowRedirects() HttpClientOption

WithNotFollowRedirects configures an HTTP client to not follow HTTP redirects.

func WithPostHook

func WithPostHook(hook PostResponseHookFunc) HttpClientOption

WithPostHook adds a post-response hook that is called after each request completes. Multiple hooks can be added and they will be executed in the order they were added. All hooks are always executed, even if the request failed or a previous hook panicked.

func WithPreHook

func WithPreHook(hook PreRequestHookFunc) HttpClientOption

WithPreHook adds a pre-request hook that is called before each request is sent. Multiple hooks can be added and they will be executed in the order they were added. If any hook returns an error, the request is aborted and subsequent hooks are not called.

func WithProtocolRacing

func WithProtocolRacing() HttpClientOption

WithProtocolRacing configures a client to race HTTP/3 (QUIC) and HTTP/2 (TCP) connections in parallel. Similar to Chrome's "Happy Eyeballs" approach, this starts both connection types simultaneously and uses whichever connects first. The client will remember which protocol worked for each host and use it directly on subsequent requests. This option is ignored if WithForceHttp1 or WithDisableHttp3 is set.

func WithProxyDialerFactory

func WithProxyDialerFactory(proxyDialerFactory ProxyDialerFactory) HttpClientOption

WithProxyDialerFactory configures an HTTP client to use a custom proxyDialerFactory instead of newConnectDialer(). This allows to implement custom proxy dialer use cases

func WithProxyUrl

func WithProxyUrl(proxyUrl string) HttpClientOption

WithProxyUrl configures an HTTP client to use the specified proxy URL.

proxyUrl should be formatted as:

"http://user:pass@host:port"

func WithRandomTLSExtensionOrder

func WithRandomTLSExtensionOrder() HttpClientOption

WithRandomTLSExtensionOrder configures a TLS client to randomize the order of TLS extensions being sent in the ClientHello.

Placement of GREASE and padding is fixed and will not be affected by this.

func WithServerNameOverwrite

func WithServerNameOverwrite(serverName string) HttpClientOption

WithServerNameOverwrite configures a TLS client to overwrite the server name being used for certificate verification and in the client hello. This option does only work properly if WithInsecureSkipVerify is set to true in addition

func WithTimeout

func WithTimeout(timeout int) HttpClientOption

WithTimeout configures an HTTP client to use the specified request timeout.

timeout is the request timeout in seconds. Deprecated: use either WithTimeoutSeconds or WithTimeoutMilliseconds

func WithTimeoutMilliseconds

func WithTimeoutMilliseconds(timeout int) HttpClientOption

WithTimeoutMilliseconds configures a hard deadline for the entire request lifecycle.

This includes connection time, redirects, and reading the response body. WARNING: If the timer expires, the connection is forcibly closed, even if you are actively downloading data.

- Use 0 to disable the deadline (Unlimited) for large downloads or long-polling. - Default is 30000 milliseconds (30 seconds).

func WithTimeoutSeconds

func WithTimeoutSeconds(timeout int) HttpClientOption

WithTimeoutSeconds configures a hard deadline for the entire request lifecycle.

This includes connection time, redirects, and reading the response body. WARNING: If the timer expires, the connection is forcibly closed, even if you are actively downloading data.

- Use 0 to disable the deadline (Unlimited) for large downloads or long-polling. - Default is 30 seconds.

func WithTransportOptions

func WithTransportOptions(transportOptions *TransportOptions) HttpClientOption

WithTransportOptions configures a client to use the specified transport options.

type Logger

type Logger interface {
	Debug(format string, args ...any)
	Info(format string, args ...any)
	Warn(format string, args ...any)
	Error(format string, args ...any)
}

func NewDebugLogger

func NewDebugLogger(logger Logger) Logger

func NewLogger

func NewLogger() Logger

func NewNoopLogger

func NewNoopLogger() Logger

type PostResponseContext

type PostResponseContext struct {
	Request  *http.Request
	Response *http.Response
	Error    error // Non-nil if request failed
}

PostResponseContext contains response metadata for PostHook handlers.

type PostResponseHookFunc

type PostResponseHookFunc func(ctx *PostResponseContext) error

PostResponseHookFunc is called after each request completes. Return an error to abort subsequent hooks, or wrap ErrContinueHooks to log and continue.

type PreRequestHookFunc

type PreRequestHookFunc func(req *http.Request) error

PreRequestHookFunc is called before each request is sent. Return an error to abort the request, or wrap ErrContinueHooks to log and continue.

type ProxyDialerFactory

type ProxyDialerFactory func(proxyUrlStr string, timeout time.Duration, localAddr *net.TCPAddr, connectHeaders http.Header, logger Logger) (proxy.ContextDialer, error)

type TLSDialerFunc

type TLSDialerFunc func(ctx context.Context, network, addr string) (net.Conn, error)

TLSDialerFunc is a function that dials a TLS connection to the given address. It's used for WebSocket connections to ensure they use the same TLS fingerprinting as regular HTTP requests.

type TransportOptions

type TransportOptions struct {
	// KeyLogWriter is an io.Writer that the TLS client will use to write the
	// TLS master secrets to. This can be used to decrypt TLS connections in
	// Wireshark and other applications.
	KeyLogWriter io.Writer
	// IdleConnTimeout is the maximum amount of time an idle (keep-alive)
	// connection will remain idle before closing itself. Zero means no limit.
	IdleConnTimeout *time.Duration
	// ReadIdleTimeout is the HTTP/2 health-check interval: a PING frame is sent
	// when no frame has been received for this long, so an idle connection
	// pings every ReadIdleTimeout. This keeps idle connections open on servers
	// that close them after an idle period. Zero disables the health check.
	ReadIdleTimeout time.Duration
	// PingTimeout closes an HTTP/2 connection whose health-check PING is not
	// acknowledged in time. Zero means 15 seconds.
	PingTimeout time.Duration
	// RootCAs is the set of root certificate authorities used to verify
	// the remote server's certificate.
	RootCAs                *x509.CertPool
	Certificates           []tls.Certificate
	MaxIdleConns           int
	MaxIdleConnsPerHost    int
	MaxConnsPerHost        int
	MaxResponseHeaderBytes int64 // Zero means to use a default limit.
	WriteBufferSize        int   // If zero, a default (currently 4KB) is used.
	ReadBufferSize         int   // If zero, a default (currently 4KB) is used.
	DisableKeepAlives      bool
	DisableCompression     bool
}

type Websocket

type Websocket struct {
	// contains filtered or unexported fields
}

func NewWebsocket

func NewWebsocket(logger Logger, options ...WebsocketOption) (*Websocket, error)

NewWebsocket creates a new WebSocket wrapper that uses tls-client for connections. This allows WebSocket connections to use the same TLS fingerprinting and configuration as regular HTTP requests.

Example usage:

// Create HTTP client with ForceHttp1 (required for WebSocket!)
client, _ := NewHttpClient(nil,
    WithClientProfile(profiles.Chrome_150),
    WithForceHttp1(),
)

// Create WebSocket with optional header ordering
headers := http.Header{
    "User-Agent": {"MyBot/1.0"},
    http.HeaderOrderKey: {"host", "upgrade", "connection", "user-agent"},
}

ws, _ := New(nil,
    WithTlsClient(client),
    WithUrl("wss://example.com/ws"),
    WithHeaders(headers),
)

conn, _ := ws.Connect(context.Background())
defer conn.Close()

func (*Websocket) Connect

func (w *Websocket) Connect(ctx context.Context) (*websocket.Conn, error)

type WebsocketOption

type WebsocketOption func(config *websocketConfig)

func WithCookiejar

func WithCookiejar(cookiejar http.CookieJar) WebsocketOption

func WithEnableCompression

func WithEnableCompression() WebsocketOption

WithEnableCompression offers permessage-deflate in the handshake (browsers and iOS URLSession do) and transparently compresses / decompresses messages when the server accepts it.

func WithHandshakeTimeoutMilliseconds

func WithHandshakeTimeoutMilliseconds(timeout int) WebsocketOption

func WithHeaders

func WithHeaders(headers http.Header) WebsocketOption

func WithReadBufferSize

func WithReadBufferSize(readBufferSize int) WebsocketOption

func WithTlsClient

func WithTlsClient(tlsClient HttpClient) WebsocketOption

WithTlsClient sets the tls-client HttpClient to use for the WebSocket connection. The underlying dialer from this client will be used to establish the connection, preserving TLS fingerprinting and other client configurations.

IMPORTANT: WebSocket connections require HTTP/1.1. When creating your HttpClient, you MUST use WithForceHttp1() option to ensure compatibility:

client, _ := NewHttpClient(nil,
    WithClientProfile(profiles.Chrome_150),
    WithForceHttp1(), // Required for WebSocket!
)

func WithUrl

func WithUrl(url string) WebsocketOption

func WithWriteBufferSize

func WithWriteBufferSize(writeBufferSize int) WebsocketOption