Resty

https://resty.dev
Admin
Resty is a simple, highly extensible, and feature-rich HTTP, REST, and Server-Sent Events (SSE)...
Tokens:29,830
Snippets:348
Trust Score:5.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get Started with SSE

Source: https://resty.dev/docs/server-sent-events

Basic implementation of an SSE source using Resty to connect to a URL and print incoming messages.

```go
sse := resty.NewSSESource().
    SetURL("https://sse.dev/test").
    OnMessage(func(e any) {
        fmt.Println(e.(*resty.SSE))
    }, nil)

err := sse.Get()
fmt.Println(err)
```

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

### Quick Start with Default Hedging

Source: https://resty.dev/docs/resilience/hedging

Initialize a Resty client with default hedging settings.

```go
// Create a Resty client with hedging
c := resty.New().
	SetHedging(resty.NewHedging())

defer c.Close()
```

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

### Perform HTTP GET request with Resty

Source: https://resty.dev/

Initialize a client and execute a GET request with tracing enabled.

```go
// HTTP, REST Client
client := resty.New()
defer client.Close()

res, err := client.R().
    SetTrace(true).
    Get("https://httpbin.org/get")
fmt.Println(err, res)
fmt.Println(res.Request.TraceInfo())
```

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

### GET Request with Query Parameters

Source: https://resty.dev/docs/example/get-request

Include query parameters, headers, and authentication tokens in a GET request.

```go
res, err := client.R().
    SetQueryParams(map[string]string{
        "page_no": "1",
        "limit":   "20",
        "sort":    "name",
        "order":   "asc",
        "random":  strconv.FormatInt(time.Now().Unix(), 10),
    }).
    SetHeader("Accept", "application/json").
    SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
    Get("/search_result")

fmt.Println(err, res)
```

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

### Simple GET Request

Source: https://resty.dev/docs/example/get-request

Perform a basic GET request to a specified URL.

```go
res, err := client.R().
    Get("https://httpbin.org/get")

fmt.Println(err, res)
```

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

### Install Resty v3 dependency

Source: https://resty.dev/

Add the Resty v3 module to your Go project.

```bash
require resty.dev/v3 v3.0.0-rc.3
```

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

### GET Request with Path Parameters

Source: https://resty.dev/docs/example/get-request

Use path parameters to dynamically construct the request URL.

```go
res, err := client.R().
    SetPathParams(map[string]string{
		"userId":       "sample@sample.com",
		"subAccountId": "100002",
	}).
    SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
    Get("/v1/users/{userId}/{subAccountId}/details")

fmt.Println(err, res)
```

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

### Set Client Certificate from File

Source: https://resty.dev/docs/client-certificates

Configures the client using PEM-encoded public and private key files.

```go
// pass the public/private key pair file paths.
// the files must contain PEM-encoded data
client.SetCertificateFromFile("certs/client.pem", "certs/client.key")
```

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

### Upload files using SetFile and SetFiles

Source: https://resty.dev/docs/multipart

Use SetFile for a single file or SetFiles for multiple files using a map of field names to file paths.

```go
// add one file
client.R().
    SetFile("my_file", "/path/to/file/sample.pdf") // field name and file path

// add multiple files together
client.R().
    SetFiles(map[string]string{
        // field name and file path
        "my_file1": "/path/to/file/sample1.pdf",
        "my_file2": "/path/to/file/sample2.pdf",
        "my_file3": "/path/to/file/sample3.pdf",
    })
```

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

### GET Request with Payload

Source: https://resty.dev/docs/example/get-request

Send a request body with a GET request by enabling the allow payload option.

```go
res, err := client.R().
    SetMethodGetAllowPayload(true). // client-level option is available
    SetContentType("application/json").
    SetBody(`{
        "query": {
            "simple_query_string" : {
                "query": "\"fried eggs\" +(eggplant | potato) -frittata",
                "fields": ["title^5", "body"],
                "default_operator": "and"
            }
        }
    }`). // this is string value as request body
    SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
    Get("/_search")

fmt.Println(err, res)
```

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

### Set Client Root Certificates from Files

Source: https://resty.dev/docs/client-root-certificates

Configures client root certificates using one or more PEM file paths.

```go
// one pem file path
client.SetClientRootCertificates("/path/to/client-root/pemFile.pem")

// one or more PEM file paths
client.SetClientRootCertificates(
    "/path/to/client-root/pemFile1.pem",
    "/path/to/client-root/pemFile2.pem",
    "/path/to/client-root/pemFile3.pem"
)

// if you already have a string slice
client.SetClientRootCertificates(certs...)
```

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

### Client.SetMethodGetAllowPayload

Source: https://resty.dev/docs/allow-payload-on

Enables request payloads for GET methods at the Client level.

```APIDOC
## Client.SetMethodGetAllowPayload

### Description
Enables the use of request payloads for GET HTTP requests globally for the Resty client.

### Usage
`client.SetMethodGetAllowPayload()`
```

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

### Set Client Certificate from String

Source: https://resty.dev/docs/client-certificates

Configures the client using raw PEM-encoded certificate and key strings.

```go
myClientCertStr := `-----BEGIN CERTIFICATE-----
... cert content ...
-----END CERTIFICATE-----`

myClientCertKeyStr := `-----BEGIN PRIVATE KEY-----
... cert key content ...
-----END PRIVATE KEY-----`

client.SetCertificateFromString(myClientCertStr, myClientCertKeyStr)
```

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

### Set Root Certificates from File

Source: https://resty.dev/docs/root-certificates

Configures root certificates using one or more PEM file paths.

```go
// one pem file path
client.SetRootCertificates("/path/to/root/pemFile.pem")

// one or more PEM file paths
client.SetRootCertificates(
    "/path/to/root/pemFile1.pem",
    "/path/to/root/pemFile2.pem",
    "/path/to/root/pemFile3.pem"
)

// if you already have a string slice
client.SetRootCertificates(certs...)
```

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

### Request.SetMethodGetAllowPayload

Source: https://resty.dev/docs/allow-payload-on

Enables request payloads for GET methods on a specific request instance.

```APIDOC
## Request.SetMethodGetAllowPayload

### Description
Enables the use of request payloads for a specific GET HTTP request.

### Usage
`request.SetMethodGetAllowPayload()`
```

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

### Manual vs Any Query Parameter Conversion

Source: https://resty.dev/docs/any-value-methods

Demonstrates the difference between manual string conversion and using the SetQueryParamAny method.

```go
// Without *Any methods - manual conversion required
c.R().
    SetQueryParam("page", strconv.Itoa(5)).
    SetQueryParam("active", strconv.FormatBool(true)).
    Get("/items")
```

```go
c := resty.New()
defer c.Close()

c.R().
    SetQueryParamAny("page", 5).
    SetQueryParamAny("active", true).
    Get("/items")

// Result:
//     /items?active=true&page=5
```

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

### Set Client Root Certificate from String

Source: https://resty.dev/docs/client-root-certificates

Configures a client root certificate directly from a PEM-encoded string.

```go
myClientRootCertStr := `-----BEGIN CERTIFICATE-----
... cert content ...
-----END CERTIFICATE-----`

client.SetClientRootCertificateFromString(myClientRootCertStr)
```

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

### Combine Form Data and Multipart

Source: https://resty.dev/docs/multipart

Demonstrates how to mix standard form data, file paths, and manual multipart field definitions in a single request.

```go
// all form data and multipart methods can be used together
client.R().
    SetFormData(map[string]string{
        "first_name": []string{"Jeevanandam"},
    }).
    SetFormDataFromValues(url.Values{
        "last_name":  []string{"M"},
    }).
    SetFiles(map[string]string{
        // field name and file path
        "profile_img": "/path/to/profile/image.png",
    }).
    SetMultipartFormData(map[string]string{
        "zip_code": "00002",
    }).
    SetMultipartField(
        "profile_img2", // field name
        "my-profile-img2.png", // file name
        "image/png", // file content-type
        bytes.NewReader(profileImg2Bytes), // io.Reader
    ).
    SetMultipartFields(
        &resty.MultipartField{
            Name:   "city",
            Values: []string{"city name here"},
        },
    )
```

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

### Initialize Resty Client

Source: https://resty.dev/docs/example/delete-request

Create a new Resty client instance and ensure it is closed after use.

```go
// create a Resty client
client := resty.New()
defer client.Close()
```

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

### Set Root Certificate from String

Source: https://resty.dev/docs/root-certificates

Configures a root certificate directly from a PEM-encoded string.

```go
myRootCertStr := `-----BEGIN CERTIFICATE-----
... cert content ...
-----END CERTIFICATE-----`

client.SetRootCertificateFromString(myRootCertStr)
```

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

### Implement Round-Robin Load Balancing

Source: https://resty.dev/docs/load-balancer-and-service-discovery

Initializes a Round-Robin load balancer with a list of URLs and assigns it to a Resty client.

```go
// create a load balancer
// accepts one or more URLs
rr, err := resty.NewRoundRobin(
    "https://example1.com",
    "https://example2.com",
    "https://example3.com",
)
if err != nil {
    log.Printf("ERROR %v", err)
    return
}

// create Resty client
c := resty.New().
    SetLoadBalancer(rr)
defer c.Close()

// start using the client ...
```

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

### Combining Multiple Any Methods

Source: https://resty.dev/docs/any-value-methods

Demonstrates chaining multiple Any-suffixed methods in a single request configuration.

```go
c := resty.New()
defer c.Close()

c.R().
    SetPathParamAny("userId", 12345).
    SetQueryParamAny("page", 1).
    SetQueryParamAny("limit", 20).
    SetQueryParamAny("active", true).
    SetHeaderAny("X-Request-Id", requestId).
    SetHeaderAny("X-Timestamp", time.Now()).
    Get("/users/{userId}/posts")
```

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

### Configure Transport Timeouts

Source: https://resty.dev/docs/resilience/timeout

Initialize a client with custom transport settings using the TransportSettings struct.

```go
// create transport with timeouts
// supply only required values; the rest will use default values
transportSettings := &resty.TransportSettings{
    IdleConnTimeout:     120 * time.Second,
    TLSHandshakeTimeout: 60 * time.Second,
}

c := resty.NewWithTransportSettings(transportSettings)
defer c.Close()

// start using the client ...
```

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

### Implement request and response middleware

Source: https://resty.dev/docs/upgrading-to-v3

Use AddRequestMiddleware and AddResponseMiddleware to inspect or mutate requests and responses.

```go
client.
    AddRequestMiddleware(func(c *resty.Client, req *resty.Request) error {
        // inspect or mutate req before Resty creates the http.Request
        return nil
    }).
    AddResponseMiddleware(func(c *resty.Client, res *resty.Response) error {
        if res.CascadeError != nil {
            return nil
        }
        // inspect response status, headers, and parsed results
        return nil
    })
```

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

### Set Headers with Verbatim Casing

Source: https://resty.dev/docs/any-value-methods

Uses SetHeaderVerbatimAny to ensure header keys are not automatically normalized.

```go
c := resty.New()
defer c.Close()

c.R().
    SetHeaderVerbatimAny("x-trace-id", 123456).
    Get("/api/resource")

// Header key preserved as: x-trace-id (not X-Trace-Id)
```

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

### Configure HTTP3 Transport for Resty

Source: https://resty.dev/docs/example/enable-http3

Initializes an http3.Transport with custom QUIC settings and attaches it to a new Resty client instance.

```go
// Refer to quic-go docs to customize configuration
// https://quic-go.net/docs/
http3Transport := &http3.Transport{
    TLSClientConfig: &tls.Config{}, // set a TLS client config, if desired
    QUICConfig: &quic.Config{ // QUIC connection options
        MaxIdleTimeout:  45 * time.Second,
        KeepAlivePeriod: 30 * time.Second,
    },
}
defer http3Transport.Close()

c := resty.New().
    SetTransport(http3Transport)
defer c.Close()

// You're ready to use HTTP3 with Resty
```

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

### Configure Basic Authentication

Source: https://resty.dev/docs/authentication

Sets basic authentication credentials for either all client requests or a single specific request.

```go
// for all requests
client.SetBasicAuth("username", "password")

// for a particular request
client.R().
    SetBasicAuth("username", "password")
```

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

### Manage client lifecycle

Source: https://resty.dev/docs/upgrading-to-v3

Use the new Close method to clean up background resources during application shutdown.

```go
client := resty.New()
defer client.Close()
```

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

### Configuring TLS Client

Source: https://resty.dev/docs/server-sent-events

Set custom TLS configurations for the underlying transport using standard crypto/tls settings.

```go
cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
if err != nil {
    log.Println(err)
    return
}

es.SetTLSClientConfig(&tls.Config{
    Certificates: []tls.Certificate{cer}
})
```

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

### Set Client Certificate from tls.Certificate

Source: https://resty.dev/docs/client-certificates

Configures the client using pre-loaded tls.Certificate objects, supporting single or multiple certificates.

```go
// loading public/private key pair from files. The files must contain PEM-encoded data.
cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
if err != nil {
    log.Printf("ERROR while loading client certificate: %v", err)
    return
}

// add client certificate
client.SetCertificates(cert)

// ...
// add one or more certificates
client.SetCertificates(cert1, cert2, cert3)
```

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

### Initialize Resty with standard OAuth2 client

Source: https://resty.dev/docs/example/oauth2-client-credentials

Use this approach when no modifications to the underlying HTTP client or transport are required, as per GoDoc recommendations.

```go
clientCredCfg := &clientcredentials.Config{
    /* initialize values ... */
}

// create a client
credClient := clientCredCfg.Client(context.Background())

// create a Resty client
c := resty.NewWithClient(credClient)
defer c.Close()

// start using a resty client
```

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

### Perform OPTIONS Request

Source: https://resty.dev/docs/example/options-head-trace-request

Execute an OPTIONS request to determine permitted HTTP methods or handle CORS preflight.

```go
res, err := client.R().
    SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
    Options("https://myapp.com/servers/nyc-dc-01")

fmt.Println(err, res)
fmt.Println(res.Header())
```

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

### Implement Weighted Round-Robin Load Balancing

Source: https://resty.dev/docs/load-balancer-and-service-discovery

Configures a Weighted Round-Robin load balancer with host weights and a recovery duration.

```go
// create a load balancer
// accepts one or more hosts
wrr, err := resty.NewWeightedRoundRobin(
    3*time.Second, // recovery duration
    []*resty.Host{
        {
            BaseURL: "https://example1.com",
            Weight:  50, // determines the percentage of requests to this host
        },
        {BaseURL: "https://example2.com", Weight: 30},
        {BaseURL: "https://example3.com", Weight: 20},
    }...,
)
if err != nil {
    log.Printf("ERROR %v", err)
    return
}

// by default, the recovery duration is 120 seconds, which can be changed as follows
// wrr.SetRecoveryDuration(3 * time.Minute)

// create Resty client
c := resty.New().
    SetLoadBalancer(wrr)
defer c.Close()

// start using the client ...
```

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

### Update import path

Source: https://resty.dev/docs/upgrading-to-v3

Replace v2 import paths with the new v3 vanity import path.

```go
import "resty.dev/v3"
```

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

### Configure Token Bucket Rate Limiter

Source: https://resty.dev/docs/rate-limiting

Initializes a token bucket rate limiter with a specified refill rate and burst capacity.

```go
rateLimiter := resty.NewRateLimitTokenBucket(100, 10)

client := resty.New().
	SetRateLimiter(rateLimiter)
```

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

### Allow Non-Read-Only Methods

Source: https://resty.dev/docs/resilience/hedging

Enable hedging for methods like POST, PUT, PATCH, and DELETE. Use with caution to avoid duplicate side effects.

```go
// allow hedging on POST, PUT, PATCH, DELETE
h := resty.NewHedging().
	SetNonReadOnlyAllowed(true)

// If you already have the hedging activated
client.Hedging().SetNonReadOnlyAllowed(true)
```

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

### Add query parameters from a raw string

Source: https://resty.dev/docs/request-query-params

Use SetQueryString to provide a pre-formatted query string for the request.

```go
c := resty.New()
defer c.Close()

c.R().
    SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more").
    Get("/search")

// Result:
//     /search?cat=resty&kw=buy+a+lot+more&productId=232&source=google&template=fresh-sample
```

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

### Customize Hedging Settings

Source: https://resty.dev/docs/resilience/hedging

Configure hedging parameters including delay, maximum concurrent requests, and rate limits.

```go
// Create a hedging instance with appropriate values
h := resty.NewHedging().
	SetDelay(10 * time.Millisecond).    // delay between requests
	SetMaxRequest(10).                  // maximum concurrent requests
	SetMaxRequestPerSecond(5.0)         // maximum requests per second (rate limit)

c := resty.New().
	SetHedging(h)

defer c.Close()

// start using the resty client with hedging feature ...
```

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

### NewWithTransportSettings

Source: https://resty.dev/docs/resilience/timeout

Initializes a new Resty client with custom transport settings, such as idle connection and TLS handshake timeouts.

```APIDOC
## NewWithTransportSettings

### Description
Initializes a new Resty client with custom transport settings. This allows for fine-tuning of network-level timeouts.

### Signature
`resty.NewWithTransportSettings(transportSettings *resty.TransportSettings)`

### Example
```go
transportSettings := &resty.TransportSettings{
    IdleConnTimeout:     120 * time.Second,
    TLSHandshakeTimeout: 60 * time.Second,
}

c := resty.NewWithTransportSettings(transportSettings)
```
```

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

### Upload using io.Reader

Source: https://resty.dev/docs/multipart

Use SetFileReader to upload bytes or an io.Reader directly.

```go
// adding bytes or io.Reader
client.R().
    SetFileReader(
        "profile_img", // field name
        "my-profile-img.png", // file name
        bytes.NewReader(profileImgBytes), // io.Reader
    )
```

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

### Configure multiple response middlewares

Source: https://resty.dev/docs/response-middleware

Sets an ordered sequence of response middlewares for the client, including custom functions and built-in Resty middleware.

```go
c := resty.New()
defer c.Close()

c.SetResponseMiddlewares(
    Custom1ResponseMiddleware,
    Custom2ResponseMiddleware,
    resty.MiddlewareResponseAutoParse, // before this, the body is not read except on the debug flow
    Custom3ResponseMiddleware,
    resty.MiddlewareResponseSaveToFile, // See, Request.SetResponseSaveFileName & Request.SetResponseSaveToFile
    Custom4ResponseMiddleware,
    Custom5ResponseMiddleware,
)
```

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

### Enable Unlimited Response Body Reads

Source: https://resty.dev/docs/unlimited-response-body-reads

Demonstrates enabling unlimited reads, auto-parsing the result, and saving the response body to a file.

```go
loginResponseFile := "login-response.txt"

res, err := client.R().
    SetHeader(hdrContentTypeKey, "application/json").
    SetBody(&User{Username: "testuser", Password: "testpass"}).
    SetResponseBodyUnlimitedReads(true).
    SetResult(&LoginResponse{}).
    SetOutputFileName(loginResponseFile).
    Post("/login")

fmt.Println(err)

fmt.Println("")
loginResponse := res.Result().(*LoginResponse)
fmt.Println("ID:", loginResponse.ID)
fmt.Println("Message:", loginResponse.Message)

fmt.Println("")
loginResponseCnt, _ := os.ReadFile(loginResponseFile)
fmt.Println("File Content:", string(loginResponseCnt))

// output:
// nil
//
// ID: success
// Message: login successful
//
// File Content: { "id": "success", "message": "login successful" }
```

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

### Register multiple request middlewares

Source: https://resty.dev/docs/request-middleware

Configures multiple middleware functions in a specific order. The Request.RawRequest instance becomes available after the MiddlewareRequestCreate middleware executes.

```go
c := resty.New()
defer c.Close()

c.SetRequestMiddlewares(
    Custom1RequestMiddleware,
    Custom2RequestMiddleware,
    resty.MiddlewareRequestCreate, // after this, `Request.RawRequest` instance is available
    Custom3RequestMiddleware,
    Custom4RequestMiddleware,
)
```

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

### Configure Sliding Window Rate Limiter

Source: https://resty.dev/docs/rate-limiting

Initializes a sliding window rate limiter to enforce a request limit over a specific time duration.

```go
rateLimiter := resty.NewRateLimitSlidingWindow(100, 10*time.Second)

client := resty.New().
	SetRateLimiter(rateLimiter)
```

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

### Initialize Resty with custom OAuth2 configuration

Source: https://resty.dev/docs/example/oauth2-client-credentials

Use this approach when modifications like custom Root CAs, SSL certificates, or transport timeouts are necessary by manually injecting the token via middleware.

```go
clientCredCfg := &clientcredentials.Config{
    /* initialize values ... */
}

// create a Resty client
c := resty.New()
defer c.Close()

// configure required Root CA, Client Root CA, or Client SSL certs
// c.SetRootCertificates("/path/to/root/pemFile.pem")
// c.SetClientRootCertificates("/path/to/client-root/pemFile.pem")
// c.SetCertificateFromFile("/path/to/certs/client.pem", "/path/to/certs/client.key")

// add custom auth request middleware
c.AddRequestMiddleware(func(c *resty.Client, req *resty.Request) error {
    // get the token from client credentials
    token, err := clientCredCfg.Token(req.Context())
    if err != nil {
        return err
    }

    // set it on the request
    req.SetAuthScheme(token.Type()). // if it is "Bearer", you can skip this line
        SetAuthToken(token.AccessToken)

    return nil
})

// start using a resty client
```

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

### Implement Custom Load Balancing Algorithm

Source: https://resty.dev/docs/load-balancer-and-service-discovery

Defines a custom load balancer by implementing the LoadBalancer interface methods.

```go
// create a custom load balancer
var _ resty.LoadBalancer = (*MyCustomAlgorithm)(nil)

// MyCustomAlgorithm struct implements a custom load balancer algorithm
type MyCustomAlgorithm struct {
	// defined required fields
}

// NextWithContext method returns the next Base URL based on the custom algorithm
func (mca *MyCustomAlgorithm) NextWithContext(ctx context.Context) (string, error) {
    // perform custom load balancer algorithm logic
    // and return Base URL or error

	return baseURL, nil
}

// Feedback method processes request feedback for the custom
// load balancer algorithm
func (mca *MyCustomAlgorithm) Feedback(rf_ *RequestFeedback) {
    // process the request feedback and use it
    // for the next Base URL calculation
}

// Close method performs cleanup for the custom load balancer
func (mca *MyCustomAlgorithm) Close() error {
    // perform cleanup activities
    // such as closing channels, etc.

    return nil
}

// initialize the custom load balancer
mc := &MyCustomAlgorithm{
    // initialize here ...
}

// create Resty client
c := resty.New().
    SetLoadBalancer(mc)
defer c.Close()

// start using the client ...
```

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

### Configure Basic Retry Settings

Source: https://resty.dev/docs/resilience/retry

Sets the retry count and wait time intervals on a Resty client.

```go
// Retry configuration can be set at the client or request level
client.
    SetRetryCount(3).
    SetRetryWaitTime(2 * time.Second).
    SetRetryMaxWaitTime(5 * time.Second)
```

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

### Implement Backpressure with Request Context

Source: https://resty.dev/docs/rate-limiting

Uses a request context with a timeout to handle cases where rate limit allowance is not granted in time.

```go
rateLimiter := resty.NewRateLimitTokenBucket(1, 1)

client := resty.New().
	SetRateLimiter(rateLimiter)

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()

_, err := client.R().
	SetContext(ctx).
	Get("https://example.com")

if errors.Is(err, resty.ErrRateLimitExceeded) {
	// request was rejected because allowance did not become available in time
}
```

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

### Implement Simple Custom Redirect Policy

Source: https://resty.dev/docs/redirect-policy

Use RedirectPolicyFunc to define a simple redirect policy using a function.

```go
client.SetRedirectPolicy(
    resty.RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
        // perform redirect logic here

        // return nil to continue; otherwise, return error to exit
        return nil
    }),
)
```

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

### Configure Custom DNS Resolver with NewWithDialer

Source: https://resty.dev/docs/example/custom-dns-resolver

Uses a custom net.Dialer with a specified net.Resolver to route DNS queries through a specific server like Quad9.

```go
package main

import (
	"context"
	"fmt"
	"net"
	"time"

	"resty.dev/v3"
)

func main() {
	dialer := &net.Dialer{
		Resolver: &net.Resolver{
			PreferGo: true,
			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
				d := net.Dialer{
					Timeout: time.Duration(20) * time.Second,
				}
				return d.DialContext(ctx, "udp", "9.9.9.9:53") // Quad9 DNS
			},
		},
	}

	c := resty.NewWithDialer(dialer)
	defer c.Close()

	res, err := c.R().Get("https://httpbin.org/get")
	fmt.Println(err, res)
}
```

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

### Client.SetCertificateFromFile

Source: https://resty.dev/docs/client-certificates

Configures the client to use a certificate and private key from specified PEM-encoded files.

```APIDOC
## Client.SetCertificateFromFile

### Description
Sets the client certificate and private key using file paths. The files must contain PEM-encoded data.

### Signature
`client.SetCertificateFromFile(certFile string, keyFile string)`
```

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

### Advanced Multipart Field Configuration

Source: https://resty.dev/docs/multipart

Shows various ways to configure multipart fields including file uploads, progress callbacks, and io.Reader support.

```go
myImageFile, _ := os.Open("/path/to/image-1.png")
myImageFileStat, _ := myImageFile.Stat()

// demonstrate with various combinations and possibilities
client.R().
    SetMultipartFields(
        []*resty.MultipartField{
            // add form data, order is preserved
            {
                Name:   "field1",
                Values: []string{"field1value1", "field1value2"},
            },
            {
                Name:   "field2",
                Values: []string{"field2value1", "field2value2"},
            },
            // add file upload
            {
                Name:             "myfile_1",
                FilePath:         "/path/to/file-1.txt",
            },
            // add file upload with progress callback
            {
                Name:             "myfile_1",
                FilePath:         "/path/to/file-1.txt",
                ProgressCallback: func(mp MultipartFieldProgress) {
    				// use the progress details
    			},
            },
            // with file name and content-type
            {
                Name:             "myimage_1",
                FileName:         "image-1.png",
                ContentType:      "image/png",
                FilePath:         "/path/to/image-1.png",
            },
            // with io.Reader and file size
            {
                Name:             "myimage_2",
                FileName:         "image-2.png",
                ContentType:      "image/png",
                Reader:           myImageFile,
                FileSize:         myImageFileStat.Size(),
            },
            // with io.Reader
            {
                Name:        "uploadManifest1",
                FileName:    "upload-file-1.json",
                ContentType: "application/json",
                Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 1", "_filename" : ["file1.txt"]}}`),
            },
            // with io.Reader and progress callback
            {
                Name:             "image-file1",
                FileName:         "image-file1.png",
                ContentType:      "image/png",
                Reader:           bytes.NewReader(fileBytes),
                ProgressCallback: func(mp MultipartFieldProgress) {
                    // use the progress details
                },
            },
        }...,
    )
```

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

### Add a single request middleware

Source: https://resty.dev/docs/request-middleware

Registers a middleware function to execute before the default request middleware. Returning a non-nil error will terminate the request preparation phase.

```go
client.AddRequestMiddleware(func(c *resty.Client, req *resty.Request) error {
    // perform logic here

    return nil
})
```

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

### Implement Constant Delay Strategy

Source: https://resty.dev/docs/resilience/retry

Configures a constant delay for retries using either manual wait time settings or a dedicated strategy function.

```go
// Retry configuration can be set at the client or request level
// set same value for both min and max wait time
constantDelay := 2 * time.Second
client.
   SetRetryCount(3).
   SetRetryWaitTime(constantDelay).
   SetRetryMaxWaitTime(constantDelay)
```

```go
// Retry configuration can be set at the client or request level
client.
    SetRetryCount(3).
    SetRetryDelayStrategy(resty.RetryConstantDelayStrategy(2 * time.Second))
```

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

### Implement SRV Weighted Round-Robin Discovery

Source: https://resty.dev/docs/load-balancer-and-service-discovery

Uses SRV records to discover hosts and applies weighted round-robin distribution.

```go
// create a load balancer
swrr, err := resty.NewSRVWeightedRoundRobin(
    "_sample-server",
    "tcp", // default proto is tcp
    "example.com",
    "https", // default scheme is https
)
if err != nil {
    log.Printf("ERROR %v", err)
    return
}

// by default, the SRV records refresh duration is 180 seconds, which can be changed as follows
// swrr.SetRefreshDuration(1 * time.Hour)

// by default, the recovery duration is 120 seconds, which can be changed as follows
// swrr.SetRecoveryDuration(3 * time.Minute)

// create Resty client
c := resty.New().
    SetLoadBalancer(swrr)
defer c.Close()

// start using the client ...
```

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

### Custom Types with fmt.Stringer

Source: https://resty.dev/docs/any-value-methods

Shows how types implementing the fmt.Stringer interface are automatically converted using their String() method.

```go
type Status int

const (
    StatusPending Status = iota
    StatusApproved
    StatusRejected
)

func (s Status) String() string {
    return [...]string{"pending", "approved", "rejected"}[s]
}

c := resty.New()
defer c.Close()

c.R().
    SetQueryParamAny("status", StatusApproved).
    Get("/items")

// Result:
//     /items?status=approved
```

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

### Configure Content-Type Handling

Source: https://resty.dev/docs/response-auto-parse

Methods to set fallback or forced Content-Type headers for automatic unmarshalling.

```go
client.R().SetResponseExpectContentType("application/json")
```

```go
client.R().SetResponseForceContentType("application/json")
```

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

### Enable Debug Logging

Source: https://resty.dev/docs/debug-log

Enable debug mode globally on the client or specifically for an individual request.

```go
// enabling debug for all requests
c := resty.New().
    SetDebug(true)

// enabling debug for a particular request
req := c.R().SetDebug(true)

// few syntactic sugar methods available; see Methods section
```

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

### Consume Server-Sent Events with Resty

Source: https://resty.dev/

Configure an SSE source and define a message handler to process incoming events.

```go
// Server-Sent Events Client
sse := NewSSESource().
    SetURL("https://sse.dev/test").
    OnMessage(func(e any) {
        fmt.Println(e.(*resty.SSE))
    }, nil)

err := sse.Get()
fmt.Println(err)
```

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

### Client.SetCertificateFromString

Source: https://resty.dev/docs/client-certificates

Configures the client to use a certificate and private key provided as PEM-encoded strings.

```APIDOC
## Client.SetCertificateFromString

### Description
Sets the client certificate and private key using raw PEM-encoded strings.

### Signature
`client.SetCertificateFromString(certPEM string, keyPEM string)`
```

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

### Set Client Root Certificates with Watcher

Source: https://resty.dev/docs/client-root-certificates

Enables dynamic certificate reloading from files at specified intervals using CertWatcherOptions.

```go
// create cert watcher options
certWatcherOpts := &resty.CertWatcherOptions{
    PoolInterval: 12 * time.Hour, // default value is 24 hours
}

// one pem file path
client.SetClientRootCertificatesWatcher(certWatcherOpts, "/path/to/client-root/pemFile.pem")

// one or more PEM file paths
client.SetClientRootCertificatesWatcher(
    certWatcherOpts,
    "/path/to/client-root/pemFile1.pem",
    "/path/to/client-root/pemFile2.pem",
    "/path/to/client-root/pemFile3.pem"
)

// if you already have a string slice
client.SetClientRootCertificatesWatcher(certWatcherOpts, certs...)
```

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

### Enable and Access Request Tracing

Source: https://resty.dev/docs/request-tracing

Use EnableTrace() on a request to capture timing data, then retrieve it using res.Request.TraceInfo().

```go
// create a Resty client
client := resty.New()
defer client.Close()

res, _ = client.R().
    EnableTrace().
    Get("https://httpbin.org/get")

ti := res.Request.TraceInfo()

// Explore trace info
fmt.Println("Request Trace Info:")
fmt.Println("  DNSLookup     :", ti.DNSLookup)
fmt.Println("  ConnTime      :", ti.ConnTime)
fmt.Println("  TCPConnTime   :", ti.TCPConnTime)
fmt.Println("  TLSHandshake  :", ti.TLSHandshake)
fmt.Println("  ServerTime    :", ti.ServerTime)
fmt.Println("  ResponseTime  :", ti.ResponseTime)
fmt.Println("  TotalTime     :", ti.TotalTime)
fmt.Println("  IsConnReused  :", ti.IsConnReused)
fmt.Println("  IsConnWasIdle :", ti.IsConnWasIdle)
fmt.Println("  ConnIdleTime  :", ti.ConnIdleTime)
fmt.Println("  RequestAttempt:", ti.RequestAttempt)
fmt.Println("  RemoteAddr    :", ti.RemoteAddr.String())

// Output
// Request Trace Info:
//   DNSLookup     : 2.947333ms
//   ConnTime      : 198.844375ms
//   TCPConnTime   : 63.088834ms
//   TLSHandshake  : 132.341ms
//   ServerTime    : 64.945166ms
//   ResponseTime  : 74.625µs
//   TotalTime     : 263.774083ms
//   IsConnReused  : false
//   IsConnWasIdle : false
//   ConnIdleTime  : 0s
//   RequestAttempt: 1
//   RemoteAddr    : 3.210.94.60:443
```

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

### Implement Custom Debug Formatter

Source: https://resty.dev/docs/debug-log

Define a custom function to format debug log output and register it with the client.

```go
// implement custom debug log formatter
func DebugLogCustomFormatter(dl *DebugLog) string {
    logContent := ""

    // perform log manipulation logic here

	return logContent
}

// set the custom debug log formatter
c := resty.New().
    SetDebugLogFormatter(DebugLogCustomFormatter)
```

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

### Configure retries for non-idempotent methods

Source: https://resty.dev/docs/upgrading-to-v3

Explicitly enable retries for non-idempotent methods like POST or PATCH.

```go
client.
    SetRetryCount(2).
    SetRetryAllowNonIdempotent(true)
```

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

### Set Root Certificates with Watcher

Source: https://resty.dev/docs/root-certificates

Enables dynamic certificate reloading from files at specified intervals using CertWatcherOptions.

```go
// create cert watcher options
certWatcherOpts := &resty.CertWatcherOptions{
    PoolInterval: 12 * time.Hour, // default value is 24 hours
}

// one pem file path
client.SetRootCertificatesWatcher(certWatcherOpts, "/path/to/root/pemFile.pem")

// one or more PEM file paths
client.SetRootCertificatesWatcher(
    certWatcherOpts,
    "/path/to/root/pemFile1.pem",
    "/path/to/root/pemFile2.pem",
    "/path/to/root/pemFile3.pem"
)

// if you already have a string slice
client.SetRootCertificatesWatcher(certWatcherOpts, certs...)
```

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

### Brotli decompression with andybalholm/brotli

Source: https://resty.dev/docs/example/decompress-brotli

Integrates the andybalholm/brotli package into Resty by implementing a custom reader wrapper.

```go
c := resty.New()
defer c.Close()

// Add decompresser into Resty
client.AddContentDecompresser("br", decompressBrotli)

// Create Brotli decompress logic
func decompressBrotli(r io.ReadCloser) (io.ReadCloser, error) {
	br := &brotliReader{s: r, r: brotli.NewReader(r)}
	return br, nil
}

type brotliReader struct {
	s io.ReadCloser
	r *brotli.Reader
}

func (b *brotliReader) Read(p []byte) (n int, err error) {
	return b.r.Read(p)
}

func (b *brotliReader) Close() error {
	return b.s.Close()
}
```

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

### Configure Ratio-Based Circuit Breaker

Source: https://resty.dev/docs/resilience/circuit-breaker

Initializes a circuit breaker that opens based on the ratio of failures to total requests after a minimum request threshold is met.

```go
cb := resty.NewCircuitBreakerRatio(
    0.5,            // failureRatio
    20,             // minRequests
    30*time.Second, // resetTimeout
)

c := resty.New().
    SetCircuitBreaker(cb)
defer c.Close()
```

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

### Set Multiple Path Parameters

Source: https://resty.dev/docs/request-path-params

Uses SetPathParams with a map to replace multiple placeholders in the URL with escaped values.

```go
c := resty.New()
defer c.Close()

c.R().
    SetPathParams(map[string]string{
        "userId":       "sample@sample.com",
        "subAccountId": "100002",
        "path":         "groups/developers",
    }).
    Get("/v1/users/{userId}/{subAccountId}/{path}/details)

// Result:
//   /v1/users/sample@sample.com/100002/groups%2Fdevelopers/details
```

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

### Handling OnOpen and OnError Events

Source: https://resty.dev/docs/server-sent-events

Register callbacks to monitor connection lifecycle events and error states.

```go
sse := resty.NewSSESource().
    SetURL("https://sse.dev/test").
    OnMessage(
        func(e any) {
            fmt.Println(e.(*resty.SSE))
        },
        nil,
    ).
    OnError(
        func(err error) {
			fmt.Println("Error occurred:", err)
		},
    ).
    OnOpen(
        func(url string, resHdr http.Header) {
            fmt.Println("I'm connected:", url, resHdr)
        },
    )

err := sse.Get()
fmt.Println(err)

// Output:
// I'm connected: https://sse.dev/test map[Access-Control-Allow-Origin:[*] Cache-Control:[no-cache] Connection:[keep-alive] Content-Type:[text/event-stream] Date:[Sun, 14 Dec 2025 06:29:46 GMT] Server:[nginx/1.27.5]]
// &{  {"testing":true,"sse_dev":"is great","msg":"It works!","now":1765693786165}}
// &{  {"testing":true,"sse_dev":"is great","msg":"It works!","now":1765693788165}}
// &{  {"testing":true,"sse_dev":"is great","msg":"It works!","now":1765693790165}}
//  ...
```

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

### Set Multiple Raw Path Parameters

Source: https://resty.dev/docs/request-path-params

Uses SetRawPathParams with a map to replace multiple placeholders without applying URL escaping.

```go
c := resty.New()
defer c.Close()

c.R().
    SetRawPathParams(map[string]string{
        "userId":       "sample@sample.com",
        "subAccountId": "100002",
        "path":         "groups/developers",
    }).
    Get("/v1/users/{userId}/{subAccountId}/{path}/details")

// Result:
//     /v1/users/sample@sample.com/100002/groups/developers/details
```

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

### Configure Hedging Rate Limiting

Source: https://resty.dev/docs/resilience/hedging

Set the maximum number of hedged requests allowed per second.

```go
// allow max 10 hedged requests per second
h := resty.NewHedging().
	SetMaxRequestPerSecond(10.0)

// If you already have the hedging activated
client.Hedging().SetMaxRequestPerSecond(10.0)
```

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

### Configure Redirect Policies

Source: https://resty.dev/docs/redirect-policy

Set one or more redirect policies on the Resty client to control how redirects are handled.

```go
// The default Go client allows up to 10 redirects.
// In Resty, configure it as follows.
client.SetRedirectPolicy(resty.RedirectFlexiblePolicy(5))

// set one or more redirect policies together
client.SetRedirectPolicy(resty.RedirectFlexiblePolicy(5),
    resty.RedirectDomainCheckPolicy("host1.com", "host2.org", "host3.net"))
```

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

### Track multipart upload progress

Source: https://resty.dev/docs/multipart

Implement a ProgressCallback to monitor upload progress for individual multipart fields.

```go
progressCallback := func(mp resty.MultipartFieldProgress) {
    // progress argument provides all the required details
    fmt.Println("Name:", mp.Name)
    fmt.Println("FileName:", mp.FileName)
    fmt.Println("FileSize:", mp.FileSize)
    fmt.Println("Written:", mp.Written)
}

myImageFile, _ := os.Open("/path/to/image-1.png")
myImageFileStat, _ := myImageFile.Stat()

// demonstrate with various possibilities
client.R().
    SetMultipartFields(
        []*resty.MultipartField{
            // minimum required field, rest of the values are inferred
            // it is recommended to take advantage of input fields
            {
                Name:             "myfile_1",
                FilePath:         "/path/to/file-1.txt",
                ProgressCallback: progressCallback,
            },
            // with file name and content-type
            {
                Name:             "myimage_1",
                FileName:         "image-1.png",
                ContentType:      "image/png",
                FilePath:         "/path/to/image-1.png",
                ProgressCallback: progressCallback,
            },
            // with io.Reader and file size
            {
                Name:             "myimage_2",
                FileName:         "image-2.png",
                ContentType:      "image/png",
                Reader:           myImageFile,
                FileSize:         myImageFileStat.Size(),
                ProgressCallback: progressCallback,
            },
        }...,
    )
```

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

### Implement Zstandard Decompression in Resty

Source: https://resty.dev/docs/example/decompress-zstandard

Register a custom decompressor using AddContentDecompresser and define a reader wrapper to handle the Zstandard stream.

```go
c := resty.New()
defer c.Close()

// Add decompresser into Resty
client.AddContentDecompresser("zstd", decompressZstd)

// Create Zstandard decompress logic
func decompressZstd(r io.ReadCloser) (io.ReadCloser, error) {
	zr, err := zstd.NewReader(r)
	if err != nil {
		return nil, err
	}
	z := &zstdReader{s: r, r: zr}
	return z, nil
}

type zstdReader struct {
	s io.ReadCloser
	r *zstd.Decoder
}

func (b *zstdReader) Read(p []byte) (n int, err error) {
	return b.r.Read(p)
}

func (b *zstdReader) Close() error {
	b.r.Close()
	return b.s.Close()
}
```

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

### Client.SetCertificates

Source: https://resty.dev/docs/client-certificates

Configures the client with one or more pre-loaded tls.Certificate objects.

```APIDOC
## Client.SetCertificates

### Description
Adds one or more pre-loaded certificates to the client for SSL authentication.

### Signature
`client.SetCertificates(certs ...tls.Certificate)`
```

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

### Handling Multiple Event Types

Source: https://resty.dev/docs/server-sent-events

Use AddEventListener to register handlers for specific event names alongside the default message handler.

```go
type UserEvent struct {
    UserName string    `json:"username"`
    Message  string    `json:"msg"`
    Time     time.Time `json:"time"`
}

sse := resty.NewSSESource().
    SetURL("https://sse.dev/test").
    OnMessage(
        func(e any) {
            fmt.Println(e.(*resty.SSE))
        },
        nil,
    ).
    AddEventListener(
        "user_connect",
        func(e any) {
            fmt.Println(e.(*UserEvent))
        },
        UserEvent{},
    ).
    AddEventListener(
        "user_message",
        func(e any) {
            fmt.Println(e.(*UserEvent))
        },
        UserEvent{},
    )

err := sse.Get()
fmt.Println(err)
```

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

### Brotli decompression with dsnet/compress

Source: https://resty.dev/docs/example/decompress-brotli

Integrates the dsnet/compress package into Resty, requiring explicit error handling during reader initialization.

```go
c := resty.New()
defer c.Close()

// Add decompresser into Resty
client.AddContentDecompresser("br", decompressBrotli)

// Create Brotli decompress logic
func decompressBrotli(r io.ReadCloser) (io.ReadCloser, error) {
	br, err := brotli.NewReader(r, nil)
	if err != nil {
		return nil, err
	}
	b := &brotliReader{s: r, r: br}
	return b, nil
}

type brotliReader struct {
	s io.ReadCloser
	r *brotli.Reader
}

func (b *brotliReader) Read(p []byte) (n int, err error) {
	return b.r.Read(p)
}

func (b *brotliReader) Close() error {
	_ = b.r.Close()
	return b.s.Close()
}
```

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

### Generate and print a curl command

Source: https://resty.dev/docs/curl-command

Enables curl command generation on a request and retrieves the resulting string for output.

```go
c := resty.New()
defer c.Close()

res, _ := c.R().
    SetGenerateCurlCmd(true).
    SetBody(map[string]string{
        "name": "Resty",
    }).
    Post("https://httpbin.org/post")

curlCmdStr := res.Request.CurlCmd()
fmt.Println(curlCmdStr)

// Result:
// curl -X POST -H 'Accept-Encoding: gzip, deflate' -H 'Content-Type: application/json' -H 'User-Agent: go-resty/3.0.0 (https://resty.dev)' -d '{"name":"Resty"}' https://httpbin.org/post
```

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

### Client.SetClientRootCertificates

Source: https://resty.dev/docs/client-root-certificates

Sets the client root certificates from one or more PEM file paths.

```APIDOC
## SetClientRootCertificates

### Description
Sets the client root certificates from one or more PEM file paths.

### Signature
`func (c *Client) SetClientRootCertificates(pemFiles ...string) *Client`

### Parameters
- **pemFiles** (string...) - Required - One or more paths to PEM files.
```
Tokens:
Raw