HTTPCloak

https://pkg.go.dev/github.com/sardanioss/httpcloak
Admin
HTTPCloak is a library that emulates Chrome browser transport layer fingerprints (TLS, HTTP/2,...
Tokens:89,380
Snippets:690
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Go Quick Start: GET Request with Custom Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Execute a GET request with custom headers. The headers are provided as a map of string slices.

```go
// Custom headers
resp, _ = c.Get(ctx, "https://httpbin.org/headers", map[string][]string{
    "X-Custom": {"value"},
})

```

--------------------------------

### Go Quick Start: Initialize Client and Simple GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initialize an httpcloak client with a preset and perform a simple GET request. Remember to close the client when done.

```go
import (
    "context"
    "github.com/sardanioss/httpcloak/client"
)

// Simple request
c := client.NewClient("chrome-latest")
defer c.Close()

resp, _ := c.Get(ctx, "https://example.com", nil)
body, _ := resp.Text()
fmt.Println(resp.StatusCode, resp.Protocol)

```

--------------------------------

### Node.js Quick Start: Initialize Session and Simple GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Create an httpcloak session with a preset and perform a simple GET request. Close the session when finished.

```javascript
import httpcloak from "httpcloak";

// Simple request
const session = new httpcloak.Session({ preset: "chrome-latest" });
const r = await session.get("https://example.com");
console.log(r.statusCode, r.protocol);

```

--------------------------------

### Python Quick Start: GET Request with Custom Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Make a GET request and include custom headers. This is useful for specific API requirements or testing header handling.

```python
# Custom headers
r = httpcloak.get("https://httpbin.org/headers",
    headers={"X-Custom": "value"},
    preset="chrome-latest"
)

```

--------------------------------

### Node.js Quick Start: GET Request with Custom Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Make a GET request and include custom headers. The `headers` option is used to pass custom header key-value pairs.

```javascript
// Custom headers
const r = await session.get("https://httpbin.org/headers", {
    headers: { "X-Custom": "value" }
});

session.close();

```

--------------------------------

### Example Use Cases

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Demonstrates various ways to use the httpcloak library for different scenarios.

```APIDOC
## Example Use Cases

### Basic HTTP Requests
Example: Basic HTTP requests with httpcloak.

### ECH + 0-RTT Test
Example: ECH + 0-RTT test with browserleaks using HTTP/3.

### Cloudflare Trace Endpoint
Example: Multiple requests to Cloudflare trace endpoint.

### Custom Fingerprinting
Example: Custom JA3 & Akamai Fingerprinting with httpcloak.

### High-Performance Downloads
Example: High-Performance Downloads.

### Session Management
Example: Session management with cookies.

### Session Resumption
Example: Session Resumption (0-RTT).

### Streaming Downloads
Example: Streaming Downloads with httpcloak.

### TLS-Only Mode
Example: TLS-Only Mode with httpcloak.

### Warmup & Fork
Warmup & Fork: Browser-Like Page Load and Parallel Tab Simulation.
```

--------------------------------

### Install httpcloak for Various Languages

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Install the httpcloak library using the appropriate package manager for your development environment.

```bash
pip install httpcloak        # Python
npm install httpcloak        # Node.js
go get github.com/sardanioss/httpcloak   # Go
dotnet add package HttpCloak # C#
```

--------------------------------

### Python Quick Start: Simple GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Perform a simple GET request using the httpcloak library. The response object contains status code and protocol information.

```python
import httpcloak

# Simple request
r = httpcloak.get("https://example.com", preset="chrome-latest")
print(r.status_code, r.protocol)

```

--------------------------------

### Example: Creating Headers with H

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Demonstrates how to create a map of single-value headers using the H type and then convert it to a multi-value map for a request.

```go
headers := client.H{
    "Content-Type": "application/json",
    "Accept": "application/json",
}
req := &client.Request{
    URL: "https://example.com",
    Headers: headers.ToMulti(),
}
```

--------------------------------

### Go Quick Start: POST Request with JSON

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Send a POST request with a JSON body. The `Content-Type` header must be explicitly set.

```go
// POST with JSON
jsonBody := []byte(`{"key": "value"}`)
resp, _ = c.Post(ctx, "https://httpbin.org/post",
    bytes.NewReader(jsonBody),
    map[string][]string{"Content-Type": {"application/json"}},
)

```

--------------------------------

### Initialize and execute a basic HTTP request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Create a new httpcloak client using a specific browser preset and perform a GET request.

```go
client := httpcloak.New("chrome-146")
defer client.Close()

resp, err := client.Get(ctx, "https://example.com")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(resp.Body))
```

--------------------------------

### Prepare GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Creates a prepared GET request.

```APIDOC
## Prepare GET Request

### Description
Creates a prepared GET request.

### Method
GET

### Endpoint
/api/prepare/get

### Parameters
#### Query Parameters
- **ctx** (context.Context) - Required - The context for the request.
- **url** (string) - Required - The URL for the GET request.
- **headers** (map[string][]string) - Optional - Custom headers to include in the request.

### Response
#### Success Response (200)
- **PreparedRequest** (*PreparedRequest) - The prepared GET request object.
- **error** (error) - An error if the preparation failed.
```

--------------------------------

### Local Proxy Methods

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Methods for starting and managing a local proxy server.

```APIDOC
## Local Proxy Methods

### Start Local Proxy

Starts a local proxy server.

### Method

`StartLocalProxy`

### Parameters

- **port** (int) - Required - The port to run the proxy on.
- **opts** (*LocalProxyOption) - Optional - Options to configure the proxy.

### Method

`GetSession`

Retrieves a session from the local proxy by its ID.

### Parameters

- **sessionID** (string) - Required - The ID of the session to retrieve.

### Method

`IsRunning`

Checks if the local proxy is currently running.

### Method

`ListSessions`

Lists all active session IDs managed by the proxy.

### Method

`Port`

Returns the port the local proxy is listening on.

### Method

`RegisterSession`

Registers a new session with the local proxy.

### Parameters

- **sessionID** (string) - Required - The ID for the new session.
- **session** (*Session) - Required - The session object to register.

### Method

`Stats`

Returns statistics about the local proxy.

### Method

`Stop`

Stops the local proxy server.

### Method

`UnregisterSession`

Unregisters a session from the local proxy.

### Parameters

- **sessionID** (string) - Required - The ID of the session to unregister.
```

--------------------------------

### Basic C# HttpCloak Usage

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Demonstrates simple GET, POST with JSON, and GET with custom headers using HttpCloak in C#.

```csharp
using HttpCloak;

// Simple request
using var session = new Session(preset: Presets.Chrome145);
var r = session.Get("https://example.com");
Console.WriteLine($"{r.StatusCode} {r.Protocol}");

// POST with JSON
var r = session.PostJson("https://httpbin.org/post",
    new { key = "value" }
);

// Custom headers
var r = session.Get("https://httpbin.org/headers",
    headers: new Dictionary<string, string> { ["X-Custom"] = "value" }
);

```

--------------------------------

### Get Available Fingerprint Presets

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Returns a list of available fingerprint presets that can be used when creating a new client.

```go
func Presets() []string
```

--------------------------------

### Perform GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Performs a GET request with context, returning the response or an error.

```go
func (c *Client) Get(ctx context.Context, url string) (*Response, error)
```

--------------------------------

### Create New Hooks Instance

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Initializes a new Hooks instance. This is the starting point for registering and managing request hooks.

```go
func NewHooks() *Hooks
```

--------------------------------

### Perform GET Request with Custom Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Performs a GET request with custom headers and context, returning the response or an error.

```go
func (c *Client) GetWithHeaders(ctx context.Context, url string, headers map[string][]string) (*Response, error)
```

--------------------------------

### Perform GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Performs a simple HTTP GET request within the session context. Automatically handles cookies and session state.

```go
func (s *Session) Get(ctx context.Context, url string) (*Response, error)
```

--------------------------------

### Perform HTTP/3 GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Performs a GET request over HTTP/3 to the specified URL with optional headers. Use this for retrieving resources.

```go
func (c *HTTP3Client) Get(ctx context.Context, url string, headers map[string][]string) (*Response, error)
```

--------------------------------

### Node.js Quick Start: POST Request with JSON

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Send a POST request with a JSON payload. The `json` option is used to specify the body.

```javascript
// POST with JSON
const r = await session.post("https://httpbin.org/post", {
    json: { key: "value" }
});

```

--------------------------------

### Perform Streaming GET Request with Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Performs a streaming GET request with custom headers. Allows specifying headers for the request, useful for authentication or content negotiation.

```go
func (s *Session) GetStreamWithHeaders(ctx context.Context, url string, headers map[string][]string) (*StreamResponse, error)
```

--------------------------------

### Get All Configured Pins

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

GetPins returns a slice of all configured CertificatePin objects.

```go
func (p *CertPinner) GetPins() []*CertificatePin
```

--------------------------------

### Get Certificate Pinner Instance

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

CertPinner returns the client's certificate pinner, initializing one if it does not exist.

```go
func (c *Client) CertPinner() *CertPinner
```

--------------------------------

### Python Quick Start: POST Request with JSON

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Send a POST request with a JSON payload. The `json` parameter automatically sets the Content-Type header.

```python
# POST with JSON
r = httpcloak.post("https://httpbin.org/post",
    json={"key": "value"},
    preset="chrome-latest"
)

```

--------------------------------

### Get Header Order

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Returns the current order in which headers are sent. If no custom order is set, it returns the preset's default order.

```go
func (s *Session) GetHeaderOrder() []string
```

--------------------------------

### Get ECH Config from TransportConfig

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Fetches the Encrypted Client Hello (ECH) configuration for a target host. It prioritizes custom ECH configurations, then fetches from a specified domain, or defaults to fetching from the target host.

```go
func (c *TransportConfig) GetECHConfig(ctx context.Context, targetHost string) []byte
```

--------------------------------

### Initialize client with custom options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Configure the httpcloak client with specific timeouts and proxy settings.

```go
client := httpcloak.New("chrome-146",
    httpcloak.WithTimeout(30*time.Second),
    httpcloak.WithProxy("http://user:pass@proxy:8080"),
)
```

--------------------------------

### Perform HTTP GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Get performs an HTTP GET request to the specified URL with custom headers.

```go
func (c *Client) Get(ctx context.Context, url string, headers map[string][]string) (*Response, error)
```

--------------------------------

### GET /api/stream

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Performs a streaming GET request.

```APIDOC
## GET /api/stream

### Description
Performs a streaming GET request.

### Method
GET

### Endpoint
/api/stream

### Parameters
#### Query Parameters
- **url** (string) - Required - The URL to send the GET request to.
- **headers** (map[string][]string) - Optional - Custom headers to include in the request.

### Response
#### Success Response (200)
- **StreamResponse** (*StreamResponse) - The streaming response object.
- **error** (error) - An error if the request failed.
```

--------------------------------

### Create New HTTP/3 Client

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Initializes a new HTTP/3 client with a specified preset name. Presets can configure various client behaviors.

```go
func NewHTTP3Client(presetName string) *HTTP3Client
```

--------------------------------

### Basic GET Request with httpcloak

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Use this for simple GET requests. Ensure the 'chrome-latest' preset is suitable for your needs.

```python
import httpcloak

r = httpcloak.get("https://target.com", preset="chrome-latest")

```

--------------------------------

### Client Initialization

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initialize a new HTTP client with a specified browser fingerprint preset and optional session configurations.

```APIDOC
## Client Initialization

### Description
Creates a new HTTP client with the specified browser fingerprint preset and optional session configurations.

### Function Signature
```go
func New(preset string, opts ...Option) *Client
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **preset** (string) - Required - The browser fingerprint preset to use (e.g., "chrome-latest").
- **opts** (...Option) - Optional - A variadic list of `SessionOption` to configure the client's session behavior.

### Available Presets
- "chrome-latest" (recommended), "chrome-latest-windows", "chrome-latest-linux", "chrome-latest-macos"
- "chrome-146", "chrome-145", "chrome-144", "chrome-143", "chrome-141", "chrome-133"
- "firefox-latest", "firefox-133"
- "safari-latest", "safari-18"
- "chrome-latest-ios", "safari-latest-ios"
- "chrome-latest-android"

The "-latest" aliases resolve to the newest version available in the library.

### Request Example
```go
client := httpcloak.New("chrome-latest")
defer client.Close()
```

### Response
- **(*Client)** - A pointer to the initialized HTTP client.
- **error** - An error if the client could not be initialized.
```

--------------------------------

### Create and Warmup HTTP Session (Go)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initializes a new httpcloak session with a specified browser preset and warms it up by visiting a URL. This simulates a real user's initial navigation.

```Go
session := httpcloak.NewSession("chrome-latest")
session.Warmup(ctx, "https://example.com")
session.Get(ctx, "https://example.com/api/data")  // Looks like real user
```

--------------------------------

### Add Certificate Pin from File

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

AddPinFromCertFile loads a certificate from a file and pins its public key.

```go
func (p *CertPinner) AddPinFromCertFile(certPath string, opts ...PinOption) error
```

--------------------------------

### Configure Domain Fronting with WithConnectTo

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Sets a host mapping for domain fronting, where requests to the requestHost connect to the connectHost instead.

```go
// Connect to cloudflare.com but request example.com
client.WithConnectTo("example.com", "www.cloudflare.com")
```

--------------------------------

### Client Operations in Go

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Go implementation for client initialization, request execution, proxy management, and session persistence.

```go
import "github.com/sardanioss/httpcloak/client"

// Client creation
c := client.NewClient("chrome-latest",
    client.WithTimeout(30 * time.Second),
    client.WithProxy("socks5://..."),
    client.WithRetry(3),
    client.WithoutRedirects(),
    client.WithInsecureSkipVerify(),
)
defer c.Close()

// Request methods
resp, err := c.Get(ctx, url, headers)
resp, err := c.Post(ctx, url, body, headers)
resp, err := c.Put(ctx, url, body, headers)
resp, err := c.Delete(ctx, url, headers)

// Advanced request
resp, err := c.Do(ctx, &client.Request{
    Method:        "GET",
    URL:           url,
    Headers:       map[string][]string{},
    Body:          io.Reader,
    Params:        map[string]string{},
    ForceProtocol: client.ProtocolHTTP3,
    FetchMode:     client.FetchModeCORS,
    Referer:       "https://example.com",
})

// Proxy switching
c.SetProxy(url)            // Set both TCP and UDP proxy
c.SetTCPProxy(url)         // Set TCP proxy only (H1/H2)
c.SetUDPProxy(url)         // Set UDP proxy only (H3)
c.GetProxy()               // Get current proxy
c.GetTCPProxy()            // Get current TCP proxy
c.GetUDPProxy()            // Get current UDP proxy

// Session persistence (0-RTT resumption)
c.Save("session.json")     // Save to file
c, _ = client.Load("session.json")  // Load from file
data, _ := c.Marshal()     // Export as string
c, _ = client.Unmarshal(data)  // Import from string

// Response object
resp.StatusCode
resp.Protocol
resp.Headers
resp.Body           // io.ReadCloser
resp.Text()         // (string, error)
resp.Bytes()        // ([]byte, error)
resp.JSON(&v)       // error
resp.GetHeader(key) // string
resp.IsSuccess()    // bool
resp.IsRedirect()   // bool
```

--------------------------------

### Define Client Options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Configuration types and functions for the HTTP client.

```go
type Option func(*clientConfig)
```

```go
func WithProxy(proxyURL string) Option
```

```go
func WithTimeout(d time.Duration) Option
```

--------------------------------

### HTTP3Client Initialization and Configuration

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Provides methods for creating and configuring an HTTP/3 client.

```APIDOC
## HTTP3Client

### Description
HTTP3Client is an HTTP/3 client with QUIC connection pooling.

### Methods

#### NewHTTP3Client
```go
func NewHTTP3Client(presetName string) *HTTP3Client
```

NewHTTP3Client creates a new HTTP/3 client.

#### NewHTTP3ClientWithDNS
```go
func NewHTTP3ClientWithDNS(presetName string, dnsCache interface{}) *HTTP3Client
```

NewHTTP3ClientWithDNS creates a new HTTP/3 client with shared DNS cache.

#### Close
```go
func (c *HTTP3Client) Close()
```

Close shuts down the client and all connections.

#### SetPreset
```go
func (c *HTTP3Client) SetPreset(presetName string)
```

SetPreset changes the fingerprint preset.

#### SetTimeout
```go
func (c *HTTP3Client) SetTimeout(timeout time.Duration)
```

SetTimeout sets the request timeout.

#### Stats
```go
func (c *HTTP3Client) Stats() map[string]struct {
	Total    int
	Healthy  int
	Requests int64
}
```

Stats returns QUIC connection pool statistics.
```

--------------------------------

### Perform Streaming GET Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Performs a GET request and returns a streaming response. The caller is responsible for closing the response. Suitable for large responses where reading the entire body at once is not feasible.

```go
func (s *Session) GetStream(ctx context.Context, url string) (*StreamResponse, error)
```

--------------------------------

### Create HTTP/3 Client with DNS Cache

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Initializes a new HTTP/3 client with a specified preset and a shared DNS cache. This can improve performance by reusing DNS resolutions.

```go
func NewHTTP3ClientWithDNS(presetName string, dnsCache interface{}) *HTTP3Client
```

--------------------------------

### GET UDP Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Retrieves the current UDP proxy URL.

```APIDOC
## GET UDP Proxy URL

### Description
Retrieves the current UDP proxy URL used for HTTP/3 (QUIC) connections.

### Method
GET

### Endpoint
/api/proxy/udp

### Response
#### Success Response (200)
- **proxyURL** (string) - The current UDP proxy URL. An empty string indicates no proxy is set.
```

--------------------------------

### GET TCP Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Retrieves the current TCP proxy URL.

```APIDOC
## GET TCP Proxy URL

### Description
Retrieves the current TCP proxy URL used for HTTP/1.1 and HTTP/2 connections.

### Method
GET

### Endpoint
/api/proxy/tcp

### Response
#### Success Response (200)
- **proxyURL** (string) - The current TCP proxy URL. An empty string indicates no proxy is set.
```

--------------------------------

### Session Management and Warmup

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initialize a browser-like session and perform a warmup request to simulate real user navigation.

```APIDOC
## Session Warmup

### Description
Initializes a new browser session and performs a warmup request to establish cookies and TLS state, mimicking a real user's navigation pattern.

### Method
GET

### Parameters
#### Request Body
- **url** (string) - Required - The target URL to warm up the session.
```

--------------------------------

### Enable TLS Key Logging (Go)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initializes a Go httpcloak session with TLS key logging enabled, directing output to a specified file for later decryption of TLS traffic.

```Go
session := httpcloak.NewSession("chrome-latest",
    httpcloak.WithKeyLogFile("/tmp/keys.log"),
)
```

--------------------------------

### Create New Certificate Pinner

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Use NewCertPinner to initialize a new certificate pinner instance.

```go
func NewCertPinner() *CertPinner
```

--------------------------------

### New BasicAuth Constructor

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Creates a new BasicAuth instance with the provided username and password.

```go
func NewBasicAuth(username, password string) *BasicAuth
```

--------------------------------

### Get UDP Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Retrieves the currently configured UDP proxy URL for the session. This is specifically for UDP-level proxying.

```go
func (s *Session) GetUDPProxy() string
```

--------------------------------

### Proxy Switching (Python)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Demonstrates how to dynamically set and retrieve proxy configurations for an httpcloak session, including TCP, UDP, and combined proxy settings.

```Python
# Proxy switching
session.set_proxy(url)         # Set both TCP and UDP proxy
session.set_tcp_proxy(url)     # Set TCP proxy only (H1/H2)
session.set_udp_proxy(url)     # Set UDP proxy only (H3)
session.get_proxy()            # Get current proxy
session.get_tcp_proxy()        # Get current TCP proxy
session.get_udp_proxy()        # Get current UDP proxy
```

--------------------------------

### Get TCP Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Retrieves the currently configured TCP proxy URL for the session. This is specifically for TCP-level proxying.

```go
func (s *Session) GetTCPProxy() string
```

--------------------------------

### Handle Streaming and Uploads

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Demonstrates downloading large files via streams and performing multipart file uploads.

```python
# Stream large downloads
stream = session.get_stream("https://example.com/large-file.zip")
print(f"Size: {stream.content_length} bytes")

with open("file.zip", "wb") as f:
    while True:
        chunk = stream.read(8192)
        if not chunk:
            break
        f.write(chunk)
stream.close()

# Iterator pattern
for chunk in session.get_stream(url).iter_content(chunk_size=8192):
    process(chunk)

# Multipart upload
r = session.post(url, files={
    "file": ("filename.jpg", file_bytes, "image/jpeg")
})
```

--------------------------------

### Get All Response Headers

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Retrieves all values associated with a given header key, performing a case-insensitive lookup. This is suitable for multi-value headers.

```go
func (r *Response) GetHeaders(key string) []string
```

--------------------------------

### Create New HTTP Client with Fingerprint

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Creates a new HTTP client with the specified browser fingerprint preset. Use `defer client.Close()` to release resources. Available presets include various Chrome, Firefox, Safari, and mobile browser versions.

```go
client := httpcloak.New("chrome-latest")
defer client.Close()

```

--------------------------------

### Get Client Cookie Jar

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Cookies returns the client's cookie jar. It returns nil if cookie handling is disabled.

```go
func (c *Client) Cookies() *CookieJar
```

--------------------------------

### Session Initialization Options (Python)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Shows various configuration options when creating an httpcloak Session object, including browser presets, proxy settings, timeouts, HTTP versions, ECH, and authentication.

```Python
# Session class
session = httpcloak.Session(
    preset="chrome-latest",       # Browser preset (default)
    proxy="socks5://...",      # Proxy URL
    timeout=30,                # Timeout in seconds
    http_version="h3",         # Force protocol: h1, h2, h3, auto
    ech_from="cloudflare.com", # ECH config source
    auth=("user", "pass"),     # Basic auth
)
```

--------------------------------

### Get Unified Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Retrieves the currently configured unified proxy URL for the session. This can include HTTP, HTTPS, or SOCKS proxies.

```go
func (s *Session) GetProxy() string
```

--------------------------------

### Configure Domain Fronting

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Sets a host mapping where requests to requestHost connect to connectHost while maintaining original SNI and Host headers.

```go
func WithConnectTo(requestHost, connectHost string) SessionOption
```

--------------------------------

### Configure TLS and Proxy Options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Functions for setting custom TLS configurations, enabling TLS-only mode, setting request timeouts, and configuring UDP proxies for MASQUE.

```go
func WithTLSConfig(tlsConfig *tls.Config) Option
```

```go
func WithTLSOnly() Option
```

```go
func WithTimeout(timeout time.Duration) Option
```

```go
func WithUDPProxy(proxyURL string) Option
```

```go
client.WithUDPProxy("masque://user:pass@brd.superproxy.io:443")
```

--------------------------------

### BasicAuth Apply Method

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Applies the Basic authentication header to the given HTTP request.

```go
func (a *BasicAuth) Apply(req *http.Request) error
```

--------------------------------

### Get Proxy URL

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

GetProxy returns the current proxy URL. If TCP and HTTP proxies differ, it returns the TCP proxy URL.

```go
func (c *Client) GetProxy() string
```

--------------------------------

### Connection Management Methods

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Methods for controlling the lifecycle and state of QUIC connections.

```go
func (t *HTTP3Transport) Close() error
```

```go
func (t *HTTP3Transport) Connect(ctx context.Context, host, port string) error
```

```go
func (t *HTTP3Transport) Refresh() error
```

--------------------------------

### Create New HTTP Client

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

NewClient creates a new HTTP client with default configuration. It attempts connections using HTTP/3, then HTTP/2, and finally HTTP/1.1 as fallbacks.

```go
func NewClient(presetName string, opts ...Option) *Client
```

--------------------------------

### Manage LocalProxy

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Structure and methods for the local HTTP proxy server.

```go
type LocalProxy struct {
	// contains filtered or unexported fields
}
```

```go
proxy := httpcloak.StartLocalProxy(8080, "chrome-146")
defer proxy.Stop()
// Configure HttpClient to use http://localhost:8080 as proxy
```

```go
func StartLocalProxy(port int, opts ...LocalProxyOption) (*LocalProxy, error)
```

```go
proxy, err := httpcloak.StartLocalProxy(8080, httpcloak.WithProxyPreset("chrome-146"))
if err != nil {
    log.Fatal(err)
}
defer proxy.Stop()
fmt.Printf("Proxy running on port %d\n", proxy.Port())
```

```go
func (p *LocalProxy) GetSession(sessionID string) *Session
```

```go
func (p *LocalProxy) IsRunning() bool
```

```go
func (p *LocalProxy) ListSessions() []string
```

```go
func (p *LocalProxy) Port() int
```

```go
func (p *LocalProxy) RegisterSession(sessionID string, session *Session) error
```

```go
session := httpcloak.NewSession("chrome-146", httpcloak.WithSessionProxy("..."))
proxy.RegisterSession("session-1", session)
// Client can now use: X-HTTPCloak-Session: session-1
```

```go
func (p *LocalProxy) Stats() map[string]interface{}
```

```go
func (p *LocalProxy) Stop() error
```

```go
func (p *LocalProxy) UnregisterSession(sessionID string) *Session
```

--------------------------------

### Get Detailed Session Cookies

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Retrieves all cookies stored in the session with complete metadata such as domain, path, and expiry. This provides the most comprehensive cookie information.

```go
func (s *Session) GetCookiesDetailed() []CookieInfo
```

--------------------------------

### TLS and ECH Configuration Methods

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Methods for managing TLS session caches and Encrypted Client Hello (ECH) settings.

```go
func (t *HTTP3Transport) GetECHConfigCache() map[string][]byte
```

```go
func (t *HTTP3Transport) GetSessionCache() tls.ClientSessionCache
```

```go
func (t *HTTP3Transport) SetDisableECH(disable bool)
```

```go
func (t *HTTP3Transport) SetECHConfig(echConfig []byte)
```

```go
func (t *HTTP3Transport) SetECHConfigCache(configs map[string][]byte)
```

--------------------------------

### Get Header Order

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

GetHeaderOrder returns the current order of HTTP headers. If no custom order is set, it returns the preset's default order.

```go
func (c *Client) GetHeaderOrder() []string
```

--------------------------------

### Get All Session Cookies

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Retrieves all cookies stored in the session, including their full metadata. Note: Bindings may return a simplified format for backward compatibility.

```go
func (s *Session) GetCookies() []CookieInfo
```

--------------------------------

### Execute HTTP Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Do executes an HTTP request, attempting HTTP/3 and falling back to HTTP/2 if the initial attempt fails.

```go
func (c *Client) Do(ctx context.Context, req *Request) (*Response, error)
```

--------------------------------

### Get Response Body as Text

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Retrieves the response body as a string. Reads and caches the body if it hasn't been accessed before. Ensure to handle potential errors during reading.

```go
func (r *Response) Text() (string, error)
```

--------------------------------

### Run Pre-Request Hooks

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Executes all registered pre-request hooks with the given request. Returns an error if any hook fails.

```go
func (h *Hooks) RunPreRequest(req *http.Request) error
```

--------------------------------

### Add Certificate Pin Hash

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

AddPin adds a certificate pin. The hash should be base64-encoded SHA256 of the certificate's SPKI. Example: "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=".

```go
func (p *CertPinner) AddPin(hash string, opts ...PinOption) *CertPinner
```

--------------------------------

### Get Connect Host from TransportConfig

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Retrieves the connection host for a given request host, applying domain fronting mappings if configured. Otherwise, returns the original host.

```go
func (c *TransportConfig) GetConnectHost(requestHost string) string
```

--------------------------------

### Perform Browser Warmup

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Fetches a page and its subresources to populate cookies, cache, and TLS session tickets.

```python
session = httpcloak.Session(preset="chrome-latest")

# Fetches page + subresources with realistic browser behavior
session.warmup("https://example.com")
```

--------------------------------

### Create Headers Map

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Creates a map[string][]string from key-value pairs. Useful for inline header creation.

```go
func MakeHeaders(keyValuePairs ...string) map[string][]string
```

--------------------------------

### Get Response Body as Bytes

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Retrieves the response body as a byte slice. Reads and caches the body if it hasn't been accessed before. Ensure to handle potential errors during reading.

```go
func (r *Response) Bytes() ([]byte, error)
```

--------------------------------

### Join URL Path

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Joins a base URL with a path.

```go
func JoinURL(base, path string) string
```

--------------------------------

### Get HTTP/3 Connection Statistics

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Retrieves statistics about the QUIC connection pool managed by the HTTP/3 client. This includes total connections, healthy connections, and request counts.

```go
func (c *HTTP3Client) Stats() map[string]struct {
	Total    int
	Healthy  int
	Requests int64
}
```

--------------------------------

### Configure Local Proxy Options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Functions to configure various aspects of the local proxy, such as connection limits, presets, session caching, and timeouts.

```go
func WithProxyMaxConnections(n int) LocalProxyOption
```

```go
func WithProxyPreset(preset string) LocalProxyOption
```

```go
func WithProxySessionCache(backend transport.SessionCacheBackend, errorCallback transport.ErrorCallback) LocalProxyOption
```

```go
func WithProxyTLSOnly() LocalProxyOption
```

```go
func WithProxyTimeout(d time.Duration) LocalProxyOption
```

```go
func WithProxyUpstream(tcpProxy, udpProxy string) LocalProxyOption
```

--------------------------------

### Get Single Response Header

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Retrieves the first value for a given header key, performing a case-insensitive lookup. For headers that can have multiple values (like Set-Cookie), use GetHeaders.

```go
func (r *Response) GetHeader(key string) string
```

--------------------------------

### Define Request and Response

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Core structures for handling HTTP requests and responses within the package.

```go
type Request struct {
	Method  string
	URL     string
	Headers map[string][]string // Multi-value headers (matches http.Header)
	Body    io.Reader           // Streaming body for uploads
	Timeout time.Duration

	// TLSOnly is a per-request override for TLS-only mode.
	// When set to true, preset HTTP headers are NOT applied - only TLS fingerprinting is used.
	// When nil, the session's TLSOnly setting is used.
	// This is useful for LocalProxy where each request can have different TLS-only settings
	// via the X-HTTPCloak-TlsOnly header.
	TLSOnly *bool
}
```

```go
type Response struct {
	StatusCode int
	Headers    map[string][]string // Multi-value headers (matches http.Header)
	Body    io.ReadCloser       // Streaming body - call Close() when done
	FinalURL   string
	Protocol   string
	History    []*RedirectInfo
	// contains filtered or unexported fields
}
```

--------------------------------

### Pin Certificate From File

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Loads a certificate from a file and pins its public key.

```APIDOC
## Pin Certificate From File

### Description
Loads a certificate from a file and pins its public key.

### Method
POST

### Endpoint
/api/certificates/pin/file

### Parameters
#### Request Body
- **certPath** (string) - Required - The path to the certificate file.
- **opts** (...PinOption) - Optional - Options for pinning the certificate.
```

--------------------------------

### Configure TLS Key Logging

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Methods for enabling TLS key logging either through environment variables, manual file paths, or custom writers.

```go
// Automatic: reads from SSLKEYLOGFILE environment variable
// Just set SSLKEYLOGFILE=/path/to/keys.log before running

// Manual: set a specific file
transport.SetKeyLogFile("/path/to/keys.log")

// Custom writer
transport.SetKeyLogWriter(myWriter)
```

--------------------------------

### Request Execution and Routing

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Methods for executing HTTP requests and configuring domain fronting.

```go
func (t *HTTP3Transport) RoundTrip(req *http.Request) (*http.Response, error)
```

```go
func (t *HTTP3Transport) SetConnectTo(requestHost, connectHost string)
```

--------------------------------

### Prepare Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Creates a PreparedRequest from a Request.

```APIDOC
## Prepare Request

### Description
Creates a PreparedRequest from a Request. The PreparedRequest can be inspected, modified, and then sent.

### Method
POST

### Endpoint
/api/prepare

### Parameters
#### Request Body
- **req** (*Request) - Required - The request object to prepare.
- **ctx** (context.Context) - Required - The context for the request.

### Response
#### Success Response (200)
- **PreparedRequest** (*PreparedRequest) - The prepared request object.
- **error** (error) - An error if the preparation failed.
```

--------------------------------

### Manage Prepared Requests

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Structure and methods for inspecting and modifying a request before it is executed.

```go
type PreparedRequest struct {
	// The underlying http.Request
	HTTPRequest *http.Request

	// Original request data (for reference)
	Method  string
	URL     string
	Headers map[string][]string
	Body    []byte // Cached body bytes

	// Configuration
	Timeout       int64    // Timeout in milliseconds
	ForceProtocol Protocol // Forced protocol
	FetchMode     FetchMode
	FetchSite     FetchSite
	FetchDest     string
	Referer       string
	Auth          Auth

	// Redirect settings
	FollowRedirects bool
	MaxRedirects    int
	// contains filtered or unexported fields
}
```

```go
func (p *PreparedRequest) AddHeader(key, value string) *PreparedRequest
```

```go
func (p *PreparedRequest) DelHeader(key string) *PreparedRequest
```

```go
func (p *PreparedRequest) GetAllHeaders() http.Header
```

```go
func (p *PreparedRequest) GetHeader(key string) string
```

```go
func (p *PreparedRequest) Send(ctx context.Context) (*Response, error)
```

```go
func (p *PreparedRequest) SetAuth(auth Auth) *PreparedRequest
```

```go
func (p *PreparedRequest) SetBody(body []byte) *PreparedRequest
```

```go
func (p *PreparedRequest) SetForceProtocol(protocol Protocol) *PreparedRequest
```

```go
func (p *PreparedRequest) SetHeader(key, value string) *PreparedRequest
```

--------------------------------

### Go HttpCloak Domain Fronting

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Sets up HttpCloak client for domain fronting, specifying a different connect-to host than the target.

```go
client := httpcloak.NewClient("chrome-latest",
    httpcloak.WithConnectTo("public-cdn.com", "actual-backend.internal"),
)


```

--------------------------------

### Client Configuration Options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Options for configuring the HTTP client, such as setting proxies and timeouts.

```APIDOC
## Client Configuration

### Description
Configuration options for the HTTP client.

### Type
`Option` (func(*clientConfig))

### Functions
#### `WithProxy(proxyURL string) Option`
Sets an HTTP/HTTPS/SOCKS5 proxy.

#### `WithTimeout(d time.Duration) Option`
Sets the request timeout.
```

--------------------------------

### Create New Session

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Creates a new persistent HTTP session. Allows customization through optional SessionOption parameters.

```go
func NewSession(preset string, opts ...SessionOption) *Session
```

--------------------------------

### Constructors for HTTP3Transport

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Various factory functions to initialize an HTTP3Transport with different configurations, proxies, and features.

```go
func NewHTTP3Transport(preset *fingerprint.Preset, dnsCache *dns.Cache) (*HTTP3Transport, error)
```

```go
func NewHTTP3TransportWithConfig(preset *fingerprint.Preset, dnsCache *dns.Cache, proxyConfig *ProxyConfig, config *TransportConfig) (*HTTP3Transport, error)
```

```go
func NewHTTP3TransportWithMASQUE(preset *fingerprint.Preset, dnsCache *dns.Cache, proxyConfig *ProxyConfig, config *TransportConfig) (*HTTP3Transport, error)
```

```go
func NewHTTP3TransportWithProxy(preset *fingerprint.Preset, dnsCache *dns.Cache, proxyConfig *ProxyConfig) (*HTTP3Transport, error)
```

```go
func NewHTTP3TransportWithTransportConfig(preset *fingerprint.Preset, dnsCache *dns.Cache, config *TransportConfig) (*HTTP3Transport, error)
```

--------------------------------

### Perform POST requests

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Methods for executing POST requests with different body formats.

```go
func (c *Client) PostForm(ctx context.Context, url string, body []byte) (*Response, error)
```

```go
func (c *Client) PostJSON(ctx context.Context, url string, body []byte) (*Response, error)
```

```go
func (c *Client) PostMultipart(ctx context.Context, url string, fields []MultipartField) (*Response, error)
```

--------------------------------

### Configure Redirects and Retries

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Options to control automatic redirect behavior and retry logic.

```go
func WithoutRedirects() Option
```

```go
func WithoutRetry() Option
```

--------------------------------

### Local Proxy Configuration Options

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Options for configuring the local proxy, including port, fingerprint presets, timeouts, and upstream proxies.

```APIDOC
## Local Proxy Configuration

### Description
Configuration options for the local proxy server.

### Type
`LocalProxyOption` (func(*LocalProxyConfig))

### Struct
#### `LocalProxyConfig`
Configuration for the local proxy.
- **Port** (int) - Port to listen on (0 = auto-select).
- **Preset** (string) - Browser fingerprint preset (default: chrome-146).
- **Timeout** (time.Duration) - Request timeout.
- **MaxConnections** (int) - Maximum concurrent connections.
- **TCPProxy** (string) - Upstream TCP proxy (optional).
- **UDPProxy** (string) - Upstream UDP proxy (optional).
- **TLSOnly** (bool) - If true, only apply TLS fingerprinting, pass HTTP headers through unchanged. Useful when the client already provides authentic browser headers.
- **SessionCacheBackend** (transport.SessionCacheBackend) - Optional distributed cache for TLS sessions to enable session sharing.
- **SessionCacheErrorCallback** (transport.ErrorCallback) - Callback for session cache backend errors.

### Functions
#### `WithProxyMaxConnections(n int) LocalProxyOption`
Sets the maximum concurrent connections.

#### `WithProxyPreset(preset string) LocalProxyOption`
Sets the browser fingerprint preset.

#### `WithProxySessionCache(backend transport.SessionCacheBackend, errorCallback transport.ErrorCallback) LocalProxyOption`
Sets a distributed TLS session cache backend for the proxy, enabling TLS session ticket sharing across multiple proxy instances.

#### `WithProxyTLSOnly() LocalProxyOption`
Enables TLS-only mode where only TLS fingerprinting is applied. HTTP headers from the client pass through unchanged.

#### `WithProxyTimeout(d time.Duration) LocalProxyOption`
Sets the request timeout.

#### `WithProxyUpstream(tcpProxy, udpProxy string) LocalProxyOption`
Sets upstream proxy URLs for the httpcloak session.
```

--------------------------------

### NewHTTP1TransportWithConfig Function

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/transport

Creates a new HTTP/1.1 transport with proxy and configuration options. Requires a preset, DNS cache, proxy configuration, and transport configuration.

```go
func NewHTTP1TransportWithConfig(preset *fingerprint.Preset, dnsCache *dns.Cache, proxy *ProxyConfig, config *TransportConfig) *HTTP1Transport
```

--------------------------------

### Enable TLS Key Logging (Python)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Sets up an httpcloak session to log TLS session keys to a specified file. This allows for decryption of HTTPS traffic in tools like Wireshark.

```Python
session = httpcloak.Session(
    preset="chrome-latest",
    key_log_file="/tmp/keys.log"
)

# Make requests - keys written to file
session.get("https://example.com")

# In Wireshark: Edit → Preferences → Protocols → TLS → (Pre)-Master-Secret log filename
```

--------------------------------

### Configure Redirect Behavior

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Configures whether to follow HTTP redirects and the maximum number of redirects allowed.

```go
func WithRedirects(follow bool, maxRedirects int) SessionOption
```

--------------------------------

### Run Post-Response Hooks

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Executes all registered post-response hooks with the given response. Returns an error if any hook fails.

```go
func (h *Hooks) RunPostResponse(resp *Response) error
```

--------------------------------

### Prepare POST Request

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Creates a prepared POST request.

```APIDOC
## Prepare POST Request

### Description
Creates a prepared POST request.

### Method
POST

### Endpoint
/api/prepare/post

### Parameters
#### Query Parameters
- **ctx** (context.Context) - Required - The context for the request.
- **url** (string) - Required - The URL for the POST request.
- **body** (io.Reader) - Required - The request body.
- **headers** (map[string][]string) - Optional - Custom headers to include in the request.

### Response
#### Success Response (200)
- **PreparedRequest** (*PreparedRequest) - The prepared POST request object.
- **error** (error) - An error if the preparation failed.
```

--------------------------------

### HTTP Request Configuration

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Defines the structure for configuring and executing HTTP requests.

```go
type Request struct {
	Method  string
	URL     string
	Headers map[string][]string // Multi-value headers (matches http.Header)
	Body    io.Reader           // Streaming body for uploads
	Timeout time.Duration

	// Customization options
	UserAgent     string    // Override User-Agent (empty = use preset)
	ForceProtocol Protocol  // Force specific protocol (ProtocolAuto = auto)
	FetchMode     FetchMode // Fetch mode: Navigate (default, human click) or CORS (XHR/fetch) or NoCors (subresource)
	FetchSite     FetchSite // Sec-Fetch-Site: Auto (default), None, SameOrigin, SameSite, CrossSite
	FetchDest     string    // Sec-Fetch-Dest for NoCors mode: "script", "style", "image" (empty = mode default)
	Referer       string    // Referer header (used for auto-detecting FetchSite)

	// Authentication (overrides client-level auth)
	Auth Auth

	// Params adds query parameters to the URL
	Params map[string]string

	// Per-request redirect override (nil = use client config)
	FollowRedirects *bool
	MaxRedirects    int

	// Per-request retry override (nil = use client config)
	DisableRetry bool
}
```

--------------------------------

### Python HttpCloak Runtime Proxy Switching

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Demonstrates switching proxies dynamically during an HttpCloak session without creating new connections.

```python
session = httpcloak.Session(preset="chrome-latest")

# Start with direct connection
r = session.get("https://api.ipify.org")
print(f"Direct IP: {r.text}")

# Switch to proxy 1
session.set_proxy("http://proxy1.example.com:8080")
r = session.get("https://api.ipify.org")
print(f"Proxy 1 IP: {r.text}")

# Switch to proxy 2
session.set_proxy("socks5://proxy2.example.com:1080")
r = session.get("https://api.ipify.org")
print(f"Proxy 2 IP: {r.text}")


```

--------------------------------

### Verify Certificate Chain Against Pins

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak/client

Verify checks if the provided certificate chain matches any of the configured pins for the given host.

```go
func (p *CertPinner) Verify(host string, certs []*x509.Certificate) error
```

--------------------------------

### Fork Session for Parallel Tabs (Go)

Source: https://pkg.go.dev/github.com/sardanioss/httpcloak

Initializes a Go httpcloak session and forks it to create multiple parallel 'tabs'. Each tab simulates an independent browser tab sharing session data but using separate connections.

```Go
session := httpcloak.NewSession("chrome-latest")
session.Warmup(ctx, "https://example.com")

tabs := session.Fork(10)
for i, tab := range tabs {
    go func(t *httpcloak.Session, n int) {
        t.Get(ctx, fmt.Sprintf("https://example.com/page/%d", n))
    }(tab, i)
}
```
Tokens:
Raw