Welcome on Resty

GET Request

Mon, 01 Jan 0001 00:00:00 +0000

GET Request#

This page discusses simple GET requests. Resty features can be used across nearly all HTTP methods.

Explore the documentation for additional use cases.

Examples use request-level methods; however, Resty also includes client-level methods to configure settings for all requests.

Examples#

See Request Body Types, Allow Payload On

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

Simple#

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

fmt.Println(err, res)

With Query Params#

See Request Query Params

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)

With Path Params#

See Request Path Params

POST, PUT, PATCH Request

Mon, 01 Jan 0001 00:00:00 +0000

POST, PUT, PATCH Request#

This page discusses simple POST, PUT, and PATCH requests. Resty features can be used across nearly all HTTP methods.

Explore the documentation for additional use cases.

Examples use request-level methods; however, Resty also includes client-level methods to configure settings for all requests.

Examples#

See Request Body Types, Multipart, Form Data, etc.

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

POST#

res, err := client.R().
 SetBody(User{
 Username: "testuser",
 Password: "testpass",
 }). // default request content type is JSON
 SetResult(&LoginResponse{}). // or SetResult(LoginResponse{}).
 SetResultError(&LoginErrorResponse{}). // or SetResultError(LoginErrorResponse{}).
 Post("https://myapp.com/login")

fmt.Println(err, res)
fmt.Println(res.Result().(*LoginResponse))
fmt.Println(res.ResultError().(*LoginErrorResponse))

PUT#

res, err := client.R().
 SetBody(Article{
 Title: "Resty",
 Content: "This is my article content, oh ya!",
 Author: "Jeevanandam M",
 Tags: []string{"article", "sample", "resty"},
 }). // default request content type is JSON
 SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
 SetResultError(&Error{}). // or SetResultError(Error{}).
 Put("https://myapp.com/articles/123456")

fmt.Println(err, res)
fmt.Println(res.ResultError().(*Error))

PATCH#

resp, err := client.R().
 SetBody(Article{
 Tags: []string{"new tag1", "new tag2"},
 }). // default request content type is JSON
 SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
 SetResultError(&Error{}). // or SetResultError(Error{}).
 Patch("https://myapp.com/articles/123456")

fmt.Println(err, res)
fmt.Println(res.ResultError().(*Error))

Mon, 01 Jan 0001 00:00:00 +0000

Request Query Params#

Resty provides easy-to-add request query parameters into requests.

Example: search=kitchen%20papers&size=large

NOTE: Client-level settings can be overridden at the request level.

Examples#

Single Query Param#

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

c.R().
 SetQueryParam("search", "kitchen papers").
 SetQueryParam("size", "large").
 Get("/search")

// Result:
// /search?search=kitchen%20papers&size=large

Multiple Query Params#

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

c.R().
 SetQueryParams(map[string]string{
		"search": "kitchen papers",
		"size": "large",
	}).
 Get("/search")

// Result:
// /search?search=kitchen%20papers&size=large

Query Params from url.Values#

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

c.R().
 SetQueryParamsFromValues(url.Values{
 "status": []string{"pending", "approved", "open"},
 }).
 Get("/search")

// Result:
// /search?status=pending&status=approved&status=open

Query Params from String#

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

Methods#

Client#

Request#

DELETE Request

Mon, 01 Jan 0001 00:00:00 +0000

DELETE Request#

This page discusses simple DELETE requests. Resty features can be used across nearly all HTTP methods.

Explore the documentation for additional use cases.

Examples use request-level methods; however, Resty also includes client-level methods to configure settings for all requests.

Examples#

See Request Body Types, Allow Payload On

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

Simple#

res, err := client.R().
 SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
 SetResultError(&Error{}). // or SetResultError(Error{}).
 Delete("https://myapp.com/articles/123456")

fmt.Println(err, res)
fmt.Println(res.ResultError().(*Error))

With Payload#

See Allow Payload On

OPTIONS, HEAD, TRACE Request

Mon, 01 Jan 0001 00:00:00 +0000

OPTIONS, HEAD, TRACE Request#

This page discusses simple OPTIONS, HEAD, and TRACE requests. Resty features can be used across nearly all HTTP methods.

Explore the documentation for additional use cases.

Examples use request-level methods; however, Resty also includes client-level methods to configure settings for all requests.

Examples#

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

OPTIONS#

Commonly used to determine permitted HTTP methods or CORS preflight requests.

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

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

HEAD#

res, err = client.R().
 SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
 Head("https://myapp.com/videos/hi-res-video")

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

TRACE#

res, err = client.R().
 SetAuthToken("bc594900518b4f7eac75bd37f019e08fbc594900518b4f7eac75bd37f019e08f").
 Trace("https://myapp.com/test")

fmt.Println(err, res)

Mon, 01 Jan 0001 00:00:00 +0000

Request Path Params#

Resty provides easy-to-use dynamic request URL path params. It replaces the value of the key while composing the request URL. The value will be escaped using the url.PathEscape function.

NOTE: Client-level settings can be overridden at the request level.

Examples#

Single Path Param#

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

c.R().
 SetPathParam("userId", "sample@sample.com").
 Get("/v1/users/{userId}/details")

// Result:
// /v1/users/sample@sample.com/details

Multiple Path Params#

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

Methods#

Client#

Request#

Request Raw Path Params#

Resty provides easy-to-use dynamic request URL raw path params. It replaces the value of the key while composing the request URL. The value used as-is, no escapes applied.

Mon, 01 Jan 0001 00:00:00 +0000

Any Value Methods#

Resty provides *Any convenience methods that accept any type values and automatically convert them to strings using predefined formatting rules. These methods eliminate the need for manual strconv or fmt.Sprintf calls when working with non-string values.

NOTE: Client-level settings can be overridden at the request level.

Type Conversion Rules#

Values are converted to strings based on these rules (in order of priority):

Type	Conversion Method
`string`	Used as-is
`int`	`strconv.Itoa()`
`bool`	`strconv.FormatBool()`
`int64`	`strconv.FormatInt()`
`[]string`	`strings.Join(v, ",")`
`time.Time`	`v.Format(time.RFC3339)`
`[]byte`	`string(v)`
`float64`	`strconv.FormatFloat()`
`int32`, `int16`, `int8`	`strconv.FormatInt()`
`uint64`, `uint32`, `uint16`, `uint8`, `uint`	`strconv.FormatUint()`
`float32`	`strconv.FormatFloat()`
`fmt.Stringer`	`v.String()`
Any other type	`fmt.Sprint(v)`

Examples#

Query Params with Non-String Values#

Instead of manually converting values to strings:

Mon, 01 Jan 0001 00:00:00 +0000

Request Body Types#

Resty supports various request body types.

Resty v3 streams the content in the request body for the io.Reader interface.

Resty v3 uses a streaming approach by default to handle JSON and XML content types, improving memory efficiency. Resty also provides the In-Memory Marshal and Unmarshal section.

Setting the Content-Type header in the request skips the auto-detect computation.

It does request body automatic marshaling for struct and map data types.

Struct#

For the XML request body, set Content-Type as application/xml.

Mon, 01 Jan 0001 00:00:00 +0000

Response Auto Parse#

Out of the box, Resty automatically unmarshals JSON and XML responses based on the response header Content-Type when Request.SetResult or Request.SetResultError is used.

For custom content types or custom parsing, see Content-Type {Encoder, Decoder}.

Examples#

res, err := client.R().
 SetBody(User{
 Username: "testuser",
 Password: "testpass",
 }). // default request content-type is JSON
 SetResult(&LoginResponse{}).
 SetResultError(&LoginErrorResponse{}).
 Post("https://myapp.com/login")

fmt.Println(err)
fmt.Println(res.Result().(*LoginResponse)) // success: status code > 199 && status code < 300
fmt.Println(res.ResultError().(*LoginErrorResponse)) // error: status code > 399

SetResult and SetResultError Usage#

Examples describe the method SetResult, which applies to SetResultError.

Mon, 01 Jan 0001 00:00:00 +0000

Save Response#

Resty provides a simple method for saving/downloading HTTP responses to the file system.

Resty v3 adds -

Ability to determine the filename automatically from the response in the following order -

Request.SetResponseSaveFileName

Header Content-Disposition

Content-Disposition filename values are sanitized before use. Absolute paths and parent-directory traversal segments are rejected.

Request URL using path.Base

Request URL hostname if path is empty or “/”

Ability to use Request.SetResult and Request.SetResultError together with save response by enabling Request.SetResponseBodyUnlimitedReads, refer to unlimited response reads.

NOTE: Client-level settings can be overridden at the request level.

Mon, 01 Jan 0001 00:00:00 +0000

Root Certificates#

Resty offers a convenient method to add root certificates.

Starting in v3, Resty can use a watcher to reload certificates dynamically at configured intervals when files are modified.

Default watcher reload interval is 24 hours.

Examples#

From File#

// 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...)

From File with Watcher#

// 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...)

From String#

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

client.SetRootCertificateFromString(myRootCertStr)

Methods#

Mon, 01 Jan 0001 00:00:00 +0000

Client Root Certificates#

Resty offers a convenient method to add client root certificates.

Starting in v3, Resty can use a watcher to reload certificates dynamically at configured intervals when files are modified.

Default watcher reload interval is 24 hours.

Examples#

From File#

// 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...)

From File with Watcher#

// 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...)

From String#

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

client.SetClientRootCertificateFromString(myClientRootCertStr)

Methods#

Mon, 01 Jan 0001 00:00:00 +0000

Client Certificates#

Resty provides a convenient method to add client certificates for SSL Client authentication.

Examples#

From File#

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

From String#

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

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

client.SetCertificateFromString(myClientCertStr, myClientCertKeyStr)

From Certificates#

// 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)

Methods#

Mon, 01 Jan 0001 00:00:00 +0000

Content Decompresser#

Resty v3 provides an extensible way to handle Response content decompression. Out-of-the-box, it handles gzip and deflate decompress.

NOTE:

User-defined decompresser takes priority over default ones.

Add method overwrites decompresser if decompress directive/key already exists.

Content-Encoding directive/key is important while adding decompresser.

Content-Encoding values as re case-insensitive per RFC 9110 Section 8.4.1

Example#

Refer to the example section for Brotli (br) and Zstandard (zstd) decompress.

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

c.AddContentDecompresser("decompress directive/key here", func(r io.ReadCloser) (io.ReadCloser, error) {
 // logic goes here

 return nil, nil
})

Methods#

Content-Type {Encoder, Decoder}

Mon, 01 Jan 0001 00:00:00 +0000

Content-Type {Encoder, Decoder}#

Resty v3 provides an extensible way to handle Request and Response content types. Out-of-the-box, it handles using Go built-in package -

JSON content-type using json.Encoder and json.Decoder
XML content-type using xml.Encoder and xml.Decoder

NOTE:

User-defined encoder/decoder takes priority over default ones.

Add method overwrites encoder/decoder if Content-Type key already exists.

Resty v3 uses a streaming approach by default to handle JSON and XML content types, improving memory efficiency. Resty also provides the In-Memory Marshal and Unmarshal section.

Content-Type encoder and decoder keys are case-insensitive.

Examples#

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

c.AddContentTypeEncoder("http content type key here", func(w io.Writer, v any) error {
 // logic goes here

 return nil
})

c.AddContentTypeDecoder("http content type key here", func(r io.Reader, v any) error {
 // logic goes here

 return nil
})

In Memory Marshal and Unmarshal#

Resty v3 provides in-memory marshal and unmarshal for JSON and XML content types using Go’s built-in packages.

Mon, 01 Jan 0001 00:00:00 +0000

Request Middleware#

Resty provides request middleware that enables logic execution during the request preparation phase.

Out of the box, Resty provides:

MiddlewareRequestCreate

v3 introduces a fully composable middleware feature that allows the registration of request middleware in any order to accommodate practical use cases.

v3 introduces the Request.Funcs feature, which can help with request instance manipulation.

The Request.RawRequest instance is available after MiddlewareRequestCreate middleware execution.

Examples#

Typical Use#

Adds middleware before the default request middleware.
non-nil error return value terminates the request preparation phase.

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

 return nil
})

Advanced Use#

Users can register N request middleware functions in an order appropriate for the use case.
non-nil error return value terminates the request preparation phase.

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

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

Methods#

Client#

Request#

Request.Funcs

Mon, 01 Jan 0001 00:00:00 +0000

Response Middleware#

Resty provides response middleware that lets you run logic after receiving a response.

Out of the box, Resty provides:

v3 introduces a fully composable middleware feature that allows the registration of response middleware in any order to accommodate practical use cases.

v3 introduces the capability to cascade an error within the response middleware execution chain.

Examples#

Typical Use#

Adds middleware after the default response middleware.
Cascades errors returned by response middleware downstream via Response.CascadeError.

client.AddResponseMiddleware(func(c *resty.Client, res *resty.Response) error {
 // perform logic here

 // cascade error downstream
 // return errors.New("hey error occurred")

 return nil
})

Advanced Use#

Cascades errors returned by response middleware downstream via Response.CascadeError.

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,
)

Methods#

ResponseMiddleware

Client#

Mon, 01 Jan 0001 00:00:00 +0000

Credits#

GitHub Source Code hosting
Caddy Server
Hugo Static Website Generator
Customized version of hugo-book theme
Icons obtained from UXWing
- github-icon
- contrast-icon
- timecard-icon

Mon, 01 Jan 0001 00:00:00 +0000

Allow Payload On#

By default, Resty allows request payloads on POST, PUT, and PATCH under RFC 9110 as of June 2022.

However, GET and DELETE have historically been subject to debate or interpretation. RFC 9110 states:

request has no generally defined semantics...

So, by default, Resty disallows request payloads on the GET and DELETE HTTP verbs.

Some real-world systems use request payloads on GET and DELETE. Resty provides explicit methods to enable payloads for these verbs.

Mon, 01 Jan 0001 00:00:00 +0000

Authentication#

Resty supports the following authentication and authorization mechanisms for requests.

Basic Auth
Digest Auth
Bearer Auth Token
Custom Auth Header
Custom Auth using Request Middleware

Basic Auth#

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

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

Digest Auth#

Digest auth is supported only at the client level; create a dedicated client to use it.

Supported QOP -

auth
auth-int

Supported Hash Functions

MD5
MD5-sess
SHA-256
SHA-256-sess
SHA-512
SHA-512-sess
SHA-512-256
SHA-512-256-sess

// for all requests
client.SetDigestAuth("username", "password")

Bearer Auth Token#

The default auth scheme is Bearer, which can be changed with Client.SetAuthScheme or Request.SetAuthScheme

Mon, 01 Jan 0001 00:00:00 +0000

Curl Command#

Resty provides an option to generate the curl command for the request.

By default, Resty does not log the curl command in the debug log since it has the potential to leak sensitive data unless explicitly enabled via Client.SetCurlCmdDebugLog or Request.SetCurlCmdDebugLog.

NOTE: Client-level settings can be overridden at the request level.

NOTE:

Potential to leak sensitive data from Request and Response in the debug log when the debug log option is enabled.

Additional memory usage since the request body was reread.

curl body is not generated for io.Reader and multipart request flow.

Example#

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

Methods#

Client#

Request#

Mon, 01 Jan 0001 00:00:00 +0000

Debug Log#

The debug log provides insights into Resty’s request and response details for troubleshooting. v3 introduces debug log formatters, allowing users to customize debug log content for their use cases. Out of the box, the following formatters are available:

DebugLogFormatter (default)
DebugLogJSONFormatter

Default Behaviour#

Automatically sanitize HTTP headers in both Request and Response if the header key contains authorization, auth, or token.
Applies a human-readable debug log formatter.

Examples#

Get Started#

// 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

Editing Log Details#

Mon, 01 Jan 0001 00:00:00 +0000

Error Handling#

In Resty’s request and response flow, error handling is crucial. Check and handle errors appropriately.

Possible Area of Errors/Failures#

Request Errors: Connection, Network, Timeout, Lifecycle, Configuration, and Protocol
- DNS related (lookup, host not found, etc.)
- Connection related (refused, reset, broken, etc.)
- End of File (socket closed, etc.)
- TLS handshake (negotiation, timeout, etc.)
- URL related (invalid, malformed, etc.)
- Marshalling errors
- Resty validation errors
- Context cancellation errors
- etc.
Response Errors: Server Sent HTTP Status Codes
- Success: Typically indicated by status code 2xx range.
- Failure: Typically indicated by status code 4xx and 5xx range.

Let’s take a simple example that covers the errors above.

Mon, 01 Jan 0001 00:00:00 +0000

Custom DNS Resolver#

Resty v3 introduces additional methods for creating client instances, including the NewWithDialer function.

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)
}

Mon, 01 Jan 0001 00:00:00 +0000

Brotli Decompress#

Resty v3 allows users to add decompression logic for HTTP responses using their favorite package.

Using sync.Pool can reuse the reader and reduce allocation if the package supports Reset.

Example 1#

Package: github.com/andybalholm/brotli

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()
}

Example 2#

Package: github.com/dsnet/compress

Mon, 01 Jan 0001 00:00:00 +0000

Zstandard Decompress#

Resty v3 allows users to add decompression logic for HTTP responses using their favorite package.

Using sync.Pool can reuse the reader and reduce allocation if the package supports Reset.

Example#

Package: github.com/klauspost/compress/zstd

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()
}

Mon, 01 Jan 0001 00:00:00 +0000

Redirect History#

Resty v3 adds the redirect history feature to the response.

Method Response.RedirectHistory returns RedirectInfo slice.

package main

import (
	"fmt"

	"resty.dev/v3"
)

func main() {
	c := resty.New()
	defer c.Close()

	res, _ := c.R().Get("http://resty.dev")

	for _, rh := range res.RedirectHistory() {
		fmt.Println(rh.StatusCode, rh.URL)
	}
}

Mon, 01 Jan 0001 00:00:00 +0000

Form Data#

Resty provides a convenient method to compose form-data requests.

By default, only allowed on payload-supported HTTP verbs, see allow payload on.

Request Content-Type set as application/x-www-form-urlencoded.

Form data values are URL-encoded.

NOTE: Client-level settings can be overridden at the request level.

Examples#

From Map#

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

// login request
res, err := c.R().
	SetFormData(map[string]string{
		"username": "myusername",
		"password": "mypassword",
	}).
	Post("https://myapp.com/login")

fmt.Println(err, res)

// followed by profile update
res, err := c.R().
	SetFormData(map[string]string{
		"first_name": "Jeevanandam",
		"last_name": "M",
		"zip_code": "00001",
		"city": "new city update",
	}).
	Post("https://myapp.com/profile")

fmt.Println(err, res)

From url.Values#

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

// sample multi-value form data
criteria := url.Values{
 "search_criteria": []string{"book", "glass", "pencil"},
}
res, err := c.R().
 SetFormDataFromValues(criteria).
 Post("https://myapp.com/search")

fmt.Println(err, res)

Methods#

Client#

Client.SetFormData

Request#

Mon, 01 Jan 0001 00:00:00 +0000

Load Balancer and Service Discovery#

Resty v3 provides new ways to discover the Base URL and client-side load balancing.

Out of the box, Resty provides two algorithms:

Resty also supports SRV record discovery using the Weighted Round-Robin algorithm via NewSRVWeightedRoundRobin.

Version 2 had an SRV record lookup feature but did not use record weight values. Version 3 respects record weights and uses the appropriate weighted round-robin algorithm.

Version 3 lets users implement any custom method for determining the Base URL through the LoadBalancer interface.

Examples#

Round-Robin#

// 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 ...

Weighted Round-Robin#

// 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 ...

SRV Weighted Round-Robin#

// 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 ...

User-defined Algorithm#

Version 3 lets users implement any custom method for determining the Base URL through the LoadBalancer interface.

Mon, 01 Jan 0001 00:00:00 +0000

Multipart Form Data#

Resty provides a convenient method to compose multipart form-data or ordered form-data requests.

Only allowed on POST, PUT, and PATCH verbs.

Starting v3, ordered multipart form data is possible.

Request.SetMultipartBoundary can be used to set a custom boundary.

All form data and multipart methods can be used together.

res, err := client.R().
 SetMultipartFormData(map[string]string{
 "first_name": "Jeevanandam",
 "last_name": "M",
 "zip_code": "00001",
 }).
 Post("https://myapp.com/profile")

fmt.Println(err, res)

Ordered Form Data#

Example 1#

res, err := client.R().
 SetMultipartOrderedFormData("first_name", []string{"Jeevanandam"}).
 SetMultipartOrderedFormData("last_name", []string{"M"}).
 SetMultipartOrderedFormData("zip_code", []string{"00001"}).
 Post("https://myapp.com/profile")

fmt.Println(err, res)

Example 2#

// SetMultipartFields can be used for ordered form data
fields := []*resty.MultipartField{
 {
 Name: "field1",
 Values: []string{"field1value1", "field1value2"},
 },
 {
 Name: "field2",
 Values: []string{"field2value1", "field2value2"},
 }
}

res, err := client.R().
 SetMultipartFields(fields...). // it can be combined with SetMultipartOrderedFormData
 Post("https://myapp.com/profile")

fmt.Println(err, res)

Methods#

Request#

Multipart File Upload#

By default, Resty streams the content in the request body when a file or io.Reader is detected in the MultipartField input.

Only allowed on POST, PUT, and PATCH verbs.

Request.SetMultipartBoundary can be used to set a custom boundary.

All form data and multipart methods can be used together.

Upload#

// 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",
 })

Use io.Reader#

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

With Content-Type#

// adding bytes or io.Reader with file content-type
client.R().
 SetMultipartField(
 "profile_img", // field name
 "my-profile-img.png", // file name
 "image/png", // file content-type
 bytes.NewReader(profileImgBytes), // io.Reader
 )

Upload Progress#

Resty v3 provides optional live multipart upload progress in bytes. See:

Mon, 01 Jan 0001 00:00:00 +0000

New Features and Enhancements#

Override all transport settings and timeout values used by Resty with NewWithTransportSettings.
Fully composable request and response middleware
Content-Type {Encoder, Decoder}
Content Decompresser
Circuit Breaker
Multipart streaming and upload progress.
Load Balancer and Service Discovery
Retry
- Retry settings at the request level.
- Respects header Retry-After if present.
- Resets reader on retry request if the io.ReadSeeker interface is supported.
Root and Client Root certificates support dynamic reload by interval.
Server-Sent Events
SRV lookup now uses a weighted round-robin algorithm and respects weight values from SRV records.
Ability to set empty header value for User-Agent and Accept-Encoding.
Ability to set TLSClientConfig on custom RoundTripper via TLSClientConfiger interface.
Adds retry trace IDs and attempt details to the debug log.
Digest Auth
- Internal flow improvements and optimizations.
- Adds auth-int QOP support.
- Adds new hash functions SHA-512 and SHA-512-sess.
- Updates hash functions for SHA-512-256 and SHA-512-256-sess.
Adds Request level timeout support.
Adds the ability to determine the filename automatically from the response for saving the response.
Debug Log
- Adds a debug log formatter with built-in human-readable and JSON formats.
Client hook functions now use variadic arguments, making it easy to supply one or more values.
Any Value Methods - convenience methods (*Any variants) that accept any type values and auto-convert to strings for headers, query params, and path params.

New ways to create Client#

Client#

Request#

Response#

Middleware#

Resty v3 exports the middleware functions.

Mon, 01 Jan 0001 00:00:00 +0000

Rate Limiting#

Rate limiting helps control outbound request throughput and protects upstream services from overload.

In Resty v3, a rate limiter is configured at the client level and is consulted before every request.

NOTE: Client-level settings can be overridden at the request level.

Default Behavior#

Rate limiting is disabled by default.
Rate limiting is evaluated before each request execution.
If the configured rate limiter returns an error, request execution is aborted with that error.
Built-in rate limiters block until a slot/token is available or the request context is done.
Built-in rate limiters return ErrRateLimitExceeded when the request context is canceled or reaches its deadline before allowance is granted.

Built-in Rate Limiters#

Resty provides two ready-to-use rate limiter implementations.

Mon, 01 Jan 0001 00:00:00 +0000

Redirect Policy#

Resty provides easy-to-use redirect policy implementations and can be extended for custom use cases.

Out of the box, it provides the following redirect policies:

v3 RedirectNoPolicy returns the error http.ErrUseLastResponse.

v3 does not strip the port from the request URL host for comparison; the request URL host is used as-is.

Example#

// 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"))

Custom Redirect Policy#

There are two ways to implement a redirect policy.

Mon, 01 Jan 0001 00:00:00 +0000

Request Tracing#

Request tracing is often used to collect information about HTTP requests. Resty provides simple access to this information. These details include:

DNS Lookup Time
Connection Time
TCP Connection Time
TLS Handshake Time
Server Time
Response Time
Total Time
Whether the connection is reused
Whether the connection was idle
Connection idle time
Request Attempt
Remote Address

// 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

Methods#

Client#

Request#

Trace#

TraceInfo.String

Mon, 01 Jan 0001 00:00:00 +0000

Circuit Breaker#

Circuit breaker helps prevent cascading failures by temporarily stopping requests to unhealthy upstream services and probing for recovery.

In Resty v3, the circuit breaker is configured at the client level and checked before each request execution.

Combining circuit breaker with Retry provides a comprehensive approach to transient and sustained failures.

Default Behavior#

Circuit breaker is disabled by default.
When configured, Client.SetCircuitBreaker applies to all requests from that client.
If CircuitBreaker.Allow rejects a request, Resty returns ErrCircuitBreakerOpen immediately and does not execute request middlewares or issue a network call.
Resty applies breaker policies only when an HTTP response is available.
In half-open state, only one probe request is allowed in flight at a time.
On any state transition, breaker counters are reset.

Built-in Circuit Breaker#

Resty provides two built-in circuit breaker implementations.

Mon, 01 Jan 0001 00:00:00 +0000

Hedging#

Hedging is a latency-reduction technique that sends multiple concurrent requests and returns the first response to complete. This approach is particularly effective for handling “tail latency” - occasional slow responses that can significantly impact application performance.

Resty v3 provides an extensible Hedger interface.

Inspired by hedgedhttp and the paper Tail at Scale by Jeffrey Dean, Luiz André Barroso.

Hint: Hedging is complementary to the Retry Mechanism. Hedging optimizes latency, while retries handle failures. When hedging is enabled, retry is disabled by default; enable retry explicitly only when needed to avoid overloading your services.

Mon, 01 Jan 0001 00:00:00 +0000

Retry#

Retry plays a crucial role in modern system integration by helping handle failures effectively.

Resty provides exponential backoff with a jitter strategy out of the box; a custom retry strategy can be used to override this default.

Combining retry with Circuit Breaker provides a comprehensive approach to transient and sustained failures.

NOTE: Client-level settings can be overridden at the request level.

Default Values#

Retry count is 0
- Total retry attempts = first attempt + retry count
Retry minimum wait time is 100ms
Retry maximum wait time is 2000ms
Retry strategy is exponential backoff with a jitter

Default Behavior#

Request values are inherited from the client upon creation; they do not refresh during a retry attempt. Therefore, value updates are performed on the request instance via Response.Request.
Applies default retry conditions before user-defined retry conditions.
- This can be disabled via Client.SetRetryDefaultConditions or Request.SetRetryDefaultConditions
Executes request retry conditions first, then client retry conditions, until one returns true. Remaining conditions are not executed.
Executes request retry hooks first, then client retry hooks.
Respects header Retry-After if present.
Resets the reader automatically before a retry request if the io.ReadSeeker interface is supported. Otherwise it throws ErrReaderNotSeekable
Retries only idempotent HTTP verbs: GET, HEAD, PUT, DELETE, OPTIONS, and TRACE (RFC 9110, RFC 5789)
- Use Client.SetRetryAllowNonIdempotent or Request.SetRetryAllowNonIdempotent. If additional control is necessary, use a custom retry condition.
Request.CorrelationID - a GUID is generated when retry count > 0

Retrying Non-Idempotent Requests#

By default, Resty retries only idempotent HTTP methods. Setting SetRetryCount on a client that mostly sends POST or PATCH requests will not retry those requests unless non-idempotent retries are explicitly enabled.

Mon, 01 Jan 0001 00:00:00 +0000

Timeout#

Resty v3 allows users to modify all timeout values used by the client.

NOTE: Client-level settings can be overridden at the request level.

Examples#

Transport Timeouts#

Refer to godoc for all supported fields and their default values: TransportSettings.

// 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 ...

Client Timeout#

Resty v3 does not use http.Client.Timeout.

Mon, 01 Jan 0001 00:00:00 +0000

Server-Sent Events#

Resty v3 adds Server-Sent Events feature. It provides APIs similar to the specification and is easy to use.

Examples#

Get Started#

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

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

Auto Unmarshalling#

// https://sse.dev/test returns
// {"testing":true,"sse_dev":"is great","msg":"It works!","now":1737508994502}
type Data struct {
 Testing bool `json:"testing"`
 SSEDev string `json:"sse_dev"`
 Message string `json:"msg"`
 Now int64 `json:"now"`
}

sse := resty.NewSSESource().
 SetURL("https://sse.dev/test").
 OnMessage(
 func(e any) {
 d := e.(*Data)
 fmt.Println("Testing:", d.Testing)
 fmt.Println("SSEDev:", d.SSEDev)
 fmt.Println("Message:", d.Message)
 fmt.Println("Now:", d.Now)
 fmt.Println("")
 },
 Data{},
 )

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

// Output:
// Testing: true
// SSEDev: is great
// Message: It works!
// Now: 1737509497652

// Testing: true
// SSEDev: is great
// Message: It works!
// Now: 1737509499652

// ...

Multiple Event Types#

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)

TLS Client Config#

The method sets TLSClientConfig for underlying SSE client Transport. Values supported by https://pkg.go.dev/crypto/tls#Config can be configured.

Mon, 01 Jan 0001 00:00:00 +0000

Unlimited Response Body Reads#

Resty v3 provides the ability to read HTTP response body unlimited times.

Keeps the response body in memory, which might cause additional memory usage.

NOTE: Client-level settings can be overridden at the request level.

Example#

The provided code snippet demonstrates:

Response body auto-parsing.
Saves the response body to the file system.

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" }

Methods#

Client#

Client.SetResponseBodyUnlimitedReads

Request#

Request.SetResponseBodyUnlimitedReads

Mon, 01 Jan 0001 00:00:00 +0000

v3 Upgrade Guide#

Resty v3 release brings many new features, enhancements, and breaking changes. This page outlines upgrading Resty to v3.

Minimum required go version is go1.23

Update go.mod and imports#

Resty v3 provides a Go vanity URL.

require resty.dev/v3 v3.0.0-rc.4

Update imports from v2 to the v3 vanity import path.

import "resty.dev/v3"

Common Migration Patterns#

Common v2-to-v3 changes for client wrappers and API integrations.

Client lifecycle#

Resty v2 did not have a Client.Close method. Resty v3 adds one to run close hooks and stop client-owned background resources, such as certificate watchers and load balancers. Do not close the client after each request; for long-lived clients, close it during application shutdown.

Mon, 01 Jan 0001 00:00:00 +0000

Resty#

Released under MIT License

Resty Website and Documentation#

Released under Apache-2.0 License

Mon, 01 Jan 0001 00:00:00 +0000

Resty Timeline#

Version	Release Date	Notes
v0.1	Sep 15, 2015	Resty’s initial release
v1.0.0	Sep 25, 2017	First major release
v1.12.0	Feb 27, 2019	Final release of v1 series
v2.0.0	Jul 16, 2019	Second major release
v2.17.2	Feb 14, 2026	Final (maybe) release of v2 series
v3.0.0-rc.4	Sep 06, 2026	Third major release candidate 3
v3.0.0	TBD	Third major release

Currently v3 is in v3.0.0-rc.4

Thanks to all the Resty users and contributors, appreciated.

Enable HTTP3

Mon, 01 Jan 0001 00:00:00 +0000

Enable HTTP3#

HTTP3 is not yet included in the Go standard packages. However, the HTTP3 package is available from the community.

Package: github.com/quic-go/quic-go

Documentation: https://quic-go.net/docs/

Example#

// 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

How to do Dry-Run?

Mon, 01 Jan 0001 00:00:00 +0000

How to do Dry-Run?#

The appropriate way to do Dry-Run implementation with Resty is to implement custom transport using the http.RoundTripper interface.

With custom transport, the user could perform any use case handling for Dry-Run.

type DryRunTransport struct {
 http.RoundTripper
}

func (dr *DryRunTransport) RoundTrip(r *http.Request) (*http.Response, error) {
 // implement Dry-Run logic here ...

 return resp, err
}

c := resty.New().
 SetTransport(&DryRunTransport{
 // initialize dry-run fields
 })

defer c.Close()

// start using the Resty client with dry-run ...

OAuth2 Client Credentials

Mon, 01 Jan 0001 00:00:00 +0000

OAuth2 Client Credentials#

Without Modifying#

As per the GoDoc of clientcredentials#Config.Client

The returned Client and its Transport should not be modified.

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

Modifying#

This scenario applies to any client and transport-related configurations, such as adding Root CA, Client Root CA, Client SSL certificates, transport timeouts, and so on.

SOCKS5 Proxy

Mon, 01 Jan 0001 00:00:00 +0000

SOCKS5 Proxy#

package main

import (
	"fmt"

	"resty.dev/v3"
)

func main() {
	c := resty.New().
		SetProxy("socks5://127.0.0.1:1080")
	defer c.Close()

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

	fmt.Println(err, res)
}

TLS Client Config on Custom http.RoundTripper

Mon, 01 Jan 0001 00:00:00 +0000

TLS Client Config on Custom http.RoundTripper#

Resty v3 provides the TLSClientConfiger interface to configure TLS client configuration for custom transports implemented using the http.RoundTripper interface.

Implement `TLSClientConfiger` interface#

type CustomTransport struct {
 http.RoundTripper
 resty.TLSClientConfiger
}

func (t *CustomTransport) RoundTrip(r *http.Request) (*http.Response, error) {
 // custom round trip implementation here ...

 return resp, err
}

func (t *CustomTransport) TLSClientConfig() *tls.Config {
 // return TLS config instance

 return t.tlsConfig
}

func (t *CustomTransport) SetTLSClientConfig(tlsConfig *tls.Config) error {
 // handle TLS client config here

 return nil
}

Assign it to the Resty client#

Subsequently, construct a transport instance and assign it to the Resty client via the method Client.SetTransport.

Welcome on Resty

GET Request

GET Request#

Examples#

Simple#

With Query Params#

With Path Params#

POST, PUT, PATCH Request

POST, PUT, PATCH Request#

Examples#

POST#

PUT#

PATCH#

Request Query Params#

Examples#

Single Query Param#

Multiple Query Params#

Query Params from url.Values#

Query Params from String#

Methods#

Client#

Request#

See Also#

DELETE Request

DELETE Request#

Examples#

Simple#

With Payload#

OPTIONS, HEAD, TRACE Request

OPTIONS, HEAD, TRACE Request#

Examples#

OPTIONS#

HEAD#

TRACE#

Request Path Params#

Examples#

Single Path Param#

Multiple Path Params#

Methods#

Client#

Request#

Request Raw Path Params#

Any Value Methods#

Type Conversion Rules#

Examples#

Query Params with Non-String Values#

Request Body Types#

Struct#

Response Auto Parse#

Examples#

SetResult and SetResultError Usage#

Save Response#

Root Certificates#

Examples#

From File#

From File with Watcher#

From String#

Methods#

Client Root Certificates#

Examples#

From File#

From File with Watcher#

From String#

Methods#

Client Certificates#

Examples#

From File#

From String#

From Certificates#

Methods#

Content Decompresser#

Example#

Methods#

Content-Type {Encoder, Decoder}

Content-Type {Encoder, Decoder}#

Examples#

In Memory Marshal and Unmarshal#

Request Middleware#

Examples#

Typical Use#