
Resty is a lightweight and easy-to-use HTTP client for Go, making it a popular choice for developers.
It's designed to simplify HTTP requests, allowing you to focus on your application logic rather than dealing with the intricacies of HTTP.
With Resty, you can send GET, POST, PUT, and DELETE requests with ease, making it a versatile tool for your Go projects.
One of the key benefits of using Resty is its ability to handle JSON responses seamlessly, making it a great choice for working with APIs.
On a similar theme: Golang Go
Installation
To install Resty in your Go environment, you can use the following command to install the Resty package.
The command is a straightforward way to get started with using Resty in your Go projects.
You can use the command to install Resty and start making HTTP requests with ease.
Intriguing read: Windows Install Golang
Installing
To install Resty, use the following command in your Go environment: go get github.com/dgryski/resty/v2.
We need to install Resty in our Go environment to begin.
You can use the command go get github.com/dgryski/resty/v2 to install the Resty package.
Installing Resty is a necessary step to get started with using the package.
This command will download and install the Resty package for you.
Expand your knowledge: How to Update a Github Using Golang
New with Local Addr

If you need to create a new Resty client with a specific Local Address, you can use the NewWithLocalAddr method.
This method allows you to specify the Local Address to dial from, giving you more control over how your client connects to the network.
To use NewWithLocalAddr, you'll need to provide the Local Address as an argument to the method.
Related reading: Read a Custom Resource Using Cynamic Client Golang
Getting Started
To get started with Resty, you'll first need to install it using Go Modules. This is the recommended way to get started.
You can install Resty with a simple command, and then you're ready to start making HTTP requests. Resty supports almost all HTTP methods, including GET, POST, and DELETE.
Here are the basic steps to make a GET request with Resty:
- First, create a new Resty client.
- Next, make a GET request to the desired URL.
- Finally, print the status code and response body.
Getting Started
To get started with Resty, you'll first need to install it using Go Modules. This is the best way to ensure you have the latest version of the library.

Resty is an HTTP client library for Go, and it's surprisingly easy to use. You can make a GET request to fetch a webpage in just a few lines of code.
Here's a simple example of making a GET request to fetch a webpage:
- A new Resty client is created.
- A GET request is made to "https://example.com".
- The status code and response body are printed.
Resty supports almost all HTTP methods, including GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH, and more. This means you can use it for a wide range of tasks, from fetching web pages to sending data to a server.
To get started, you'll need to know a few basic things about Resty. Here are some of its key features:
Remember, the best way to learn how to use Resty is to start using it. Begin with a simple example, like the one above, and then experiment with different features and methods.
Fetching GitHub Repositories
Fetching GitHub Repositories is a bit more involved, but don't worry, it's still pretty straightforward.

To get started, you'll need to generate a personal access token from your GitHub account settings. This token will be used for authentication.
You'll also need to define a Repository struct to hold relevant data, like the example in the "Advanced Usage" section shows.
A Resty client is created, which is a crucial step in making API calls.
Setting the authentication token, headers, query parameters, and path parameters is where things can get a bit tricky. But don't worry, it's just a matter of following the example in the "Advanced Usage" section.
The response from the API is automatically unmarshalled into a slice of repositories. This makes it easy to work with the data.
Here's a quick rundown of the steps involved:
- Generate a personal access token
- Define a Repository struct
- Create a Resty client
- Set authentication token, headers, query parameters, and path parameters
- Unmarshal the response into a slice of repositories
Once you have the list of repositories, you can iterate over them and print their details, just like in the example.
HTTP Methods
Resty provides an easy-to-use API for making HTTP requests in Go, with a concise and chainable syntax. This allows developers to make complex requests with ease.
The library supports automatic JSON unmarshalling, making data handling a breeze. This feature is especially useful when working with APIs that return JSON responses.
Here are the HTTP methods supported by Resty:
These methods can be used to make requests to a server, and Resty provides a simple way to do so.
Get
GET requests are a fundamental part of HTTP communication, and Resty provides a simple and chainable method for making them.
Resty supports GET, POST, PUT, DELETE, HEAD, PATCH, OPTIONS, and other HTTP methods.
To send a GET request using Resty, you can utilize the .Get() method. Here’s an example that demonstrates how to retrieve a user:
Let's take a look at some of the key features of GET requests in Resty:
By using Resty's chainable methods, you can write concise and readable code for making GET requests.
Post
To execute POST requests with Resty v2, use the .SetResult() method. This method allows you to bind the response into a struct.
You can send a POST request with a JSON payload using this method. The response will be automatically bound into a struct, making it easy to work with the data.
The .SetResult() method is a powerful tool for handling POST requests with Resty v2. It streamlines the process and makes your code more efficient.
Update (Put)
To perform an update operation using Resty v2, you can utilize the .SetResult() method. This allows you to send a PUT request with a JSON payload and bind the response into a struct.
Resty v2 makes it easy to send a PUT request with a JSON payload. You can use the .SetResult() method to bind the response into a struct.
The .SetResult() method is a powerful tool for updating operations. It enables you to send a PUT request and receive a structured response.
By using Resty v2 and the .SetResult() method, you can simplify your update operations. This makes it easier to work with APIs and receive structured responses.
Take a look at this: Gcloud Api Using Golang
AllowGetMethodPayload
AllowGetMethodPayload is a method that enables the use of payloads with the GET method on a Resty client. This means users can send requests with a payload on HTTP GET method.
The SetAllowGetMethodPayload method is part of the Client object, allowing developers to control this behavior. For example, a user can use the Request.SetHeader or Request.SetHeaders method to send a request with a payload on the GET method.
Request Options
Request Options are crucial for handling various scenarios when making HTTP requests with Go Resty. The Options struct is used to hold retry settings.
You can use the Options struct to configure retry settings, which is particularly useful for handling temporary network issues or server overload.
In Go Resty, the Options struct is designed to be flexible and easy to use, allowing you to customize your request behavior to suit your needs.
See what others are reading: Golang vs Go
Passing Headers
Passing headers is a crucial aspect of making requests in Resty v2. You can include custom headers in your requests using Resty v2.
The code snippet below demonstrates how to pass headers using Resty v2: You can also use the `SetHeader` method to set a single header field and its value in the client instance or the current request.
For example, to set `Content-Type` and `Accept` as `application/json`, you can use the `SetHeader` method on the client instance or the current request. This sets the headers for all requests raised from the client instance or the current request.
You can also set multiple headers field and its values at one go in the client instance or the current request using the `SetHeaders` method. This method sets the headers for all requests raised from the client instance or the current request, and can be overridden at request level header options.
The `Header` method on the response object returns the response headers, allowing you to access and inspect the headers sent with the response.
Cookie Jar
Cookie Jar is a crucial aspect of managing cookies in your requests. It allows you to override the default cookie behavior.

You can set a custom http.CookieJar in the resty client using the SetCookieJar method. This is useful when you don't want to save cookies in API contacting.
The default CookieJar can be removed by using the SetCookieJar method. This is especially useful when you're dealing with sensitive information and want to minimize cookie storage.
Cookies set in the client instance will be added to all requests raised from that instance. This is achieved using the SetCookies method.
The Cookies method in the Response object allows you to access all the response cookies. This is useful for inspecting and verifying the cookies received from the server.
Add Condition
You can add a condition to retry a request after an error using the AddRetryAfterErrorCondition method, which was introduced in version 2.6.0.
This method adds the basic condition of retrying after encountering an error from the HTTP response.
You can also add custom retry conditions using the AddRetryCondition method, which allows you to specify a function that will be checked to determine if the request should be retried.
Readers also liked: Golang Add to Map

This method takes a function as input, which will be executed with a non-nil Response or request execution error, and if it returns true, the request will be retried.
You can add multiple retry conditions to an array of functions, and the request will retry if any of the functions return true and the error is nil.
These retry conditions are applied on all requests made using the client, unless you specify request-specific retry conditions using the *Request.AddRetryCondition method.
Discover more: Golang Create Error
Request Body
The Request Body is a crucial part of any HTTP request, and Resty makes it easy to work with. You can set the request body using the SetBody method, which supports various data types like string, []byte, struct, map, slice, and io.Reader.
Resty automatically marshals JSON and XML content types for struct, map, or slice bodies, making it a convenient option. For example, you can use a struct as the body input and Resty will handle the marshalling based on the content type.
Related reading: Golang Copy Slice
Here are some examples of supported body data types:
By using Resty's SetBody method, you can easily work with request bodies and focus on building your application.
Automatic Unmarshalling
Automatic unmarshalling is a game-changer for working with structured data. Resty takes care of automatically unmarshalling JSON responses into Go structs, making it easy to work with the data.
This simplifies handling structured data significantly, as seen in the example where a list of libraries is fetched from an API. Resty automatically unmarshals the JSON response into the Libraries struct.
With automatic unmarshalling, you can focus on writing your code without worrying about manually parsing JSON responses. This saves you time and effort, and makes your code more efficient.
Suggestion: Convert a Map to Json Golang
Multipart Fields
Multipart fields are a powerful feature in Resty for handling complex requests.
You can represent custom data parts for multipart requests using the MultipartField struct.
To set custom data using an io.Reader for multipart upload, use the SetMultipartField method.
If this caught your attention, see: Custom Controller to Monitor All Crd Golang
This method allows you to add multiple data fields using an io.Reader for multipart upload. The SetMultipartFields method is the way to do it.
Here's a breakdown of the different methods available for setting multipart fields:
You can also use the SetMultipartFormData method to attach simple form data to the request as `multipart/form-data`.
On a similar theme: Define a Map of Custom Data Type Golang
Body
The body of a request is a crucial aspect of making HTTP requests, and Resty provides several ways to work with it. You can set the body of a request using the `SetBody` method, which supports various data types such as strings, byte slices, structs, maps, and slices.
To set the body of a request, you can use the `SetBody` method, which takes a value of type `string`, `[]byte`, `struct`, `map`, `slice`, or `io.Reader` as an argument. This method is quite handy and powerful, as it supports automatic marshalling for JSON and XML content types if the body value is a struct, map, or slice.
On a similar theme: Declate a Map of String and Value as Map Golang
Resty also provides automatic unmarshalling of JSON responses into Go structs, making it easy to work with structured data. For example, if you fetch a list of libraries from an API, Resty will automatically unmarshal the JSON response into a Libraries struct.
Here are some examples of data types that can be used as a request body:
- `string`: A simple string value.
- `[]byte`: A byte slice, suitable for raw requests such as file uploads.
- `struct`: A struct value, which will be automatically marshalled into JSON or XML depending on the content type.
- `map`: A map value, which will be automatically marshalled into JSON or XML depending on the content type.
- `slice`: A slice value, which will be automatically marshalled into JSON or XML depending on the content type.
- `io.Reader`: An io.Reader value, which will be processed in bufferless mode.
Note that if you use `io.Reader` as the request body, it will be processed in bufferless mode.
Here are some examples of how to use the `SetBody` method:
- `req.SetBody("Hello, World!")`: Sets the request body to a string value.
- `req.SetBody([]byte("Hello, World!"))`: Sets the request body to a byte slice value.
- `req.SetBody(struct{Name string}{"John Doe"})`: Sets the request body to a struct value.
- `req.SetBody(map[string]string{"key": "value"})`: Sets the request body to a map value.
Resty also provides methods to set custom data using `io.Reader` for multipart uploads, such as `SetMultipartField` and `SetMultipartFields`. These methods are used to set custom data fields for multipart requests.
Authentication
Authentication is a crucial aspect of working with golang resty. You can set an auth token for all HTTP requests using the SetAuthToken method. This method sets the auth token of the Authorization header, and the default auth scheme is Bearer, which can be customized.
The auth token can be set to any string value, like BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F. This token will be added to all requests raised from the client instance.
Alternatively, you can use the SetBasicAuth method to set basic authentication for all requests. This method sets the basic authentication header in the HTTP request, and you can specify a username and password, like "go-resty" and "welcome".
Basic auth information can be overridden or set at the request level, and you can also use the Request.SetBasicAuth method to set basic auth for a specific request.
For more insights, see: Golang Set Env Variable
Configuration
To configure your Golang Resty client, you'll want to start with the basics. SetRootCertificate method helps to add one or more root certificates into Resty client.
You can also configure the client by setting the root certificate, which is a crucial step in establishing trust with the server. The SetRootCertificate method is used for this purpose.
This configuration is essential for ensuring the security and integrity of your API interactions.
BaseUrl
The BaseURL is a crucial setting in your client instance. It's used to set the base URL that will be used with requests raised from this client with relative URLs.
You can use the SetBaseURL method to set the base URL. This method is a straightforward way to define the base URL for your client instance.
Having a well-defined base URL can save you from a lot of headaches when dealing with relative URLs. It ensures that your requests are sent to the correct location.
The SetBaseURL method is a simple yet effective way to configure your client instance. It's a fundamental setting that you should have in place before making any requests.
By setting the base URL, you can avoid issues with relative URLs that might lead to incorrect requests being sent. This is especially important when working with APIs or other web services.
Recommended read: Golang Url
TLSClientConfig
TLSClientConfig is a crucial setting in Resty that determines how the client interacts with servers over TLS. It's a configuration that you can set using the `SetTLSClientConfig` method.
This method allows you to customize the TLS client configuration, which is then used by the underlying client transport. It's worth noting that this method overwrites any existing `TLSClientConfig`.
To set TLSClientConfig, you can use the `SetTLSClientConfig` method, which takes a `TLSClientConfig` object as an argument. This method is particularly useful when you need to customize the TLS client configuration for your Resty client.
Client Options
Client Options are a crucial part of fine-tuning your Resty client.
You can set client level settings using the Client struct, which applies to all requests made from the client. This includes options like all_lowercase and UPPERCASE being available.
These settings can be overridden at the request level, giving you flexibility in how you configure your client. Since v2.7.0, you've had more options to customize your client.
The Options struct holds retry settings, which you can use to control how your client behaves when encountering errors.
Expand your knowledge: Golang Copy Struct
Flexible
Flexible client options are a game-changer for making HTTP requests. FlexibleRedirectPolicy is a convenient method to create a no-redirect policy for the HTTP client.
You can use FlexibleRedirectPolicy to control how Resty handles redirects. For example, you can use it to disable redirects altogether, which can be useful in certain situations.
By using FlexibleRedirectPolicy, you can customize the behavior of your HTTP client to suit your needs. This can be especially helpful when working with APIs that don't follow standard redirect patterns.
The FlexibleRedirectPolicy method is available in Resty, and it's easy to use. It's a great feature to have, especially when working with complex APIs or networks.
Resty also provides an Options struct to hold retry settings, which can be used in conjunction with FlexibleRedirectPolicy. This allows you to fine-tune the behavior of your HTTP client even further.
By combining FlexibleRedirectPolicy with other client options, you can create a highly customized and efficient HTTP client that meets your specific needs.
Size
The Size option is a crucial one to consider when making client requests. You can rely on the HTTP `Content-Length` header, but it's not always accurate, especially for chunked transfers or compressed responses.

Resty calculates response size at the client end, giving you the actual size of the HTTP response. This is a more reliable way to get the response size, avoiding any potential inaccuracies.
You can use the Size method to get the HTTP response size in bytes. This is particularly useful when you need to know the exact size of the response, such as when working with limited bandwidth or storage.
If this caught your attention, see: Simple Http Server Golang Github
Error Handling
Error handling is a crucial part of any REST client, and Resty provides several ways to handle errors.
You can automatically unmarshal error responses from the server into a custom error object using the `SetError` method, available on both the `Client` and `Request` types. This method takes a pointer or non-pointer to an `Error` object and registers it for automatic unmarshalling if the response status code is greater than 399 and the content type is either JSON or XML.
Resty also provides a way to check if a response is an error using the `IsError` method on the `Response` type, which returns `true` if the HTTP status code is 400 or greater, and `false` otherwise. This can be useful for custom error handling logic.
Curious to learn more? Check out: Golang Comments
Add After Error

When you're dealing with errors in your code, it's essential to consider when to retry. Add After Error is a strategy that can help you handle these situations more effectively.
Since v2.6.0, the Client's AddRetryAfterErrorCondition function has been available, allowing you to add a basic condition for retrying after an error is encountered from an HTTP response.
This function is specifically designed to handle errors that occur due to issues with the HTTP response, and it's a great tool to have in your error handling toolkit.
A unique perspective: Golang Reflect to Call Function in Package
IsError
The IsError method is a crucial tool for determining if an HTTP response has resulted in an error. It's used in conjunction with the Response object, which contains information about the HTTP response.
You can use the IsError method to check if the HTTP status code is 400 or greater, which indicates an error. This is useful when working with APIs that return error responses in JSON or XML format.

The IsError method is simple to use and can be called on a Response object to get a boolean value indicating whether the response is an error. This makes it easy to write conditional code to handle errors in a robust way.
In the context of error handling, the IsError method is an essential tool for distinguishing between successful and unsuccessful responses. By using this method, you can write more reliable and fault-tolerant code that can handle errors gracefully.
Here's an interesting read: Golang Source
No
The NoRedirectPolicy in Golang Resty is a game-changer for developers who want to disable redirects in their HTTP client.
NoRedirectPolicy is used to disable redirects in the HTTP client, which can be super useful when you need to handle requests that shouldn't be redirected.
By using NoRedirectPolicy, you can avoid unnecessary redirects and ensure that your application behaves as expected.
This policy is particularly useful when dealing with APIs that don't support redirects or when you need to handle requests that require a specific response.
For another approach, see: T Golang
HTTP Client
The HTTP Client in Resty is a powerful tool for making HTTP requests. It's used to create a new client instance with client-level settings that apply to all requests.
You can use the Client struct to create a Resty client with client-level settings, which can be overridden at the request level. For example, you can set all_lowercase and UPPERCASE as available.
Resty also provides a NewWithClient method to create a new client instance with a given http.Client. This can be useful if you want to reuse an existing client instance.
The GetClient method returns the current http.Client used by the Resty client. This can be useful for debugging or logging purposes.
The HTTP client is used in the Rester project, a CLI tool for making HTTP requests. It uses the Cobra, Survey, and Resty packages to provide a user-friendly interface for making HTTP requests.
You can use the SetCookie method to append a single cookie to the client instance, which will be added to all requests. This can be useful for tracking user sessions or authentication.
The SetCookieJar method sets a custom http.CookieJar in the Resty client, allowing you to override the default cookie handling behavior. This can be useful if you want to disable cookie saving or use a custom cookie jar.
The SetTransport method sets a custom http.Transport or http.RoundTripper implementation in the Resty client. This can be useful if you want to customize the underlying transport layer or use a custom proxy.
The R method creates a new request instance, which can be used to make HTTP requests. It's used in the Rester project to implement the GET, POST, PUT, PATCH, and DELETE methods.
Response
The Response struct in GoResty holds the response values of an executed request, and one way to access its body is by using the String method, which returns the body as a String.
The IsSuccess method is a useful tool to determine if the HTTP status code falls within the 200-299 range, indicating a successful response.
You can retrieve the HTTP status string for a request using the Status method, providing a clear indication of the response's outcome.
The StatusCode method returns the actual HTTP status code for a request, allowing you to perform more specific checks and actions based on the status.
Logging

Logging is a crucial aspect of any application, and Resty provides several options for logging requests and responses.
You can set a response log callback using the OnResponseLog method, which gets called before Resty logs the information.
The SetLogger method sets a writer for logging Resty request and response details, and it's compliant with the resty.Logger interface.
The Logger interface abstracts the logging from Resty, giving users control over the choice of logger.
The RequestLog and ResponseLog structs are used to collect information from Resty requests and responses for debug logging.
You can enable debug mode on the Resty client using the SetDebug method, which logs details of every request and response.
The SetDebugBodyLimit method sets the maximum size for which the response and request body will be logged in debug mode.
You can disable the Resty client trace using the DisableTrace method.
Related reading: Golang Run Debug Mode
Conclusion
You've made it to the end of this comprehensive guide on using Resty v2 in Go. Resty v2 simplifies RESTful API consumption, enabling you to focus on building robust and efficient applications.

Importing the Resty v2 package from github.com/go-resty/resty/v2 is a crucial step to get started. Remember to handle errors effectively.
To enhance API interactions, you can pass headers, providing increased customization and security. This will help you adapt the examples to fit your specific API endpoints and requirements.
By binding API responses into Go structs, you can easily handle and manipulate data. This feature makes working with APIs a breeze.
Explore further: Golang Restful
Featured Images: pexels.com

