package module
v0.2.13 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Nov 21, 2015 License: MIT Imports: 17 Imported by: 13



GoRequest -- Simplified HTTP client ( inspired by famous SuperAgent lib in Node.js )


"Shooting Requests like a Machine Gun" - Gopher

Sending request would never been fun and easier than this. It comes with lots of feature:

  • Get/Post/Put/Head/Delete/Patch
  • Set - simple header setting
  • JSON - made it simple with JSON string as a parameter
  • Proxy - sending request via proxy
  • Timeout - setting timeout for a request
  • TLSClientConfig - taking control over tls where at least you can disable security check for https
  • RedirectPolicy
  • Cookie - setting cookies for your request
  • CookieJar - automatic in-memory cookiejar
  • BasicAuth - setting basic authentication header
  • more to come..


$ go get github.com/parnurzeal/gorequest


See Go Doc or Go Walker for usage and details.


Drone Build Status Travis Build Status

Why should you use GoRequest?

GoRequest makes thing much more simple for you, making http client more awesome and fun like SuperAgent + golang style usage.

This is what you normally do for a simple GET without GoRequest:

resp, err := http.Get("http://example.com/")

With GoRequest:

request := gorequest.New()
resp, body, errs := request.Get("http://example.com/").End()

Or below if you don't want to reuse it for other requests.

resp, body, errs := gorequest.New().Get("http://example.com/").End()

How about getting control over HTTP client headers, redirect policy, and etc. Things is getting more complicated in golang. You need to create a Client, setting header in different command, ... to do just only one GET

client := &http.Client{
  CheckRedirect: redirectPolicyFunc,

req, err := http.NewRequest("GET", "http://example.com", nil)

req.Header.Add("If-None-Match", `W/"wyzzy"`)
resp, err := client.Do(req)

Why making things ugly while you can just do as follows:

request := gorequest.New()
resp, body, errs := request.Get("http://example.com").
  Set("If-None-Match", `W/"wyzzy"`).

DELETE, HEAD, POST, PUT, PATCH are now supported and can be used the same way as GET:

request := gorequest.New()
resp, body, errs := request.Post("http://example.com").End()
// PUT -> request.Put("http://example.com").End()
// DELETE -> request.Delete("http://example.com").End()
// HEAD -> request.Head("http://example.com").End()

For a JSON POST with standard libraries, you might need to marshal map data structure to json format, setting header to 'application/json' (and other headers if you need to) and declare http.Client. So, you code become longer and hard to maintain:

m := map[string]interface{}{
  "name": "backy",
  "species": "dog",
mJson, _ := json.Marshal(m)
contentReader := bytes.NewReader(mJson)
req, _ := http.NewRequest("POST", "http://example.com", contentReader)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Notes","GoRequest is coming!")
client := &http.Client{}
resp, _ := client.Do(req)

Compared to our GoRequest version, JSON is for sure a default. So, it turns out to be just one simple line!:

request := gorequest.New()
resp, body, errs := request.Post("http://example.com").
  Set("Notes","gorequst is coming!").
  Send(`{"name":"backy", "species":"dog"}`).

Moreover, it also supports struct type. So, you can have a fun Mix & Match sending the different data types for your request:

type BrowserVersionSupport struct {
  Chrome string
  Firefox string
ver := BrowserVersionSupport{ Chrome: "37.0.2041.6", Firefox: "30.0" }
request := gorequest.New()
resp, body, errs := request.Post("http://version.com/update").

Not only for Send() but Query() is also supported. Just give it a try! :)


Moreover, GoRequest also supports callback function. This gives you much more flexibility on using it. You can use it any way to match your own style! Let's see a bit of callback example:

func printStatus(resp gorequest.Response, body string, errs []error){


In the case when you are behind proxy, GoRequest can handle it easily with Proxy func:

request := gorequest.New().Proxy("http://proxy:999")
resp, body, errs := request.Get("http://example-proxy.com").End()
// To reuse same client with no_proxy, use empty string:
resp, body, errs = request.Proxy("").("http://example-no-proxy.com").End()

Basic Authentication

To add a basic authentication header:

request := gorequest.New().SetBasicAuth("username", "password")
resp, body, errs := request.Get("http://example-proxy.com").End()


Timeout can be set in any time duration using time package:

request := gorequest.New().Timeout(2*time.Millisecond)
resp, body, errs:= request.Get("http://example.com").End()

Timeout func defines both dial + read/write timeout to the specified time parameter.


Thanks to @jaytaylor, we now have EndBytes to use when you want the body as bytes.

The callbacks work the same way as with End, except that a byte array is used instead of a string.

resp, bodyBytes, errs := gorequest.New().Get("http://example.com/").EndBytes()


For debugging, GoRequest leverages httputil to dump details of every request/response. (Thanks to @dafang)

You can just use SetDebug to enable/disable debug mode and SetLogger to set your own choice of logger.

Thanks to @QuentinPere, we can see even how gorequest is compared to CURL by using SetCurlCommand.


As the underlying gorequest is based on http.Client in most use cases, gorequest.New() should be called once and reuse gorequest as much as possible.

Contributing to GoRequest:

If you find any improvement or issue you want to fix, feel free to send me a pull request with testing.

Thanks to all contributors thus far:

@kemadz, @austinov, @figlief, @dickeyxxx, @killix, @jaytaylor, @na-ga, @dafang, @alaingilbert, @6david9, @pencil001, @QuentinPerez, @smallnest, and @piotrmiskiewicz.

Also, co-maintainer is needed here. If anyone is interested, please email me (parnurzeal at gmail.com)


  • Renee French - the creator of Gopher mascot
  • Wisi Mongkhonsrisawat for providing an awesome GoRequest's Gopher image :)


GoRequest is MIT License.



Package gorequest inspired by Nodejs SuperAgent provides easy-way to write http client



View Source
const (
	POST   = "POST"
	GET    = "GET"
	HEAD   = "HEAD"
	PUT    = "PUT"

HTTP methods we support


View Source
var DisableTransportSwap = false
View Source
var Types = map[string]string{
	"html":       "text/html",
	"json":       "application/json",
	"xml":        "application/xml",
	"text":       "text/plain",
	"urlencoded": "application/x-www-form-urlencoded",
	"form":       "application/x-www-form-urlencoded",
	"form-data":  "application/x-www-form-urlencoded",


This section is empty.


type Request

type Request *http.Request

type Response

type Response *http.Response

type SuperAgent

type SuperAgent struct {
	Url               string
	Method            string
	Header            map[string]string
	TargetType        string
	ForceType         string
	Data              map[string]interface{}
	SliceData         []interface{}
	FormData          url.Values
	QueryData         url.Values
	BounceToRawString bool
	RawString         string
	Client            *http.Client
	Transport         *http.Transport
	Cookies           []*http.Cookie
	Errors            []error
	BasicAuth         struct{ Username, Password string }
	Debug             bool
	CurlCommand       bool
	// contains filtered or unexported fields

A SuperAgent is a object storing all request data for client.

func New

func New() *SuperAgent

Used to create a new SuperAgent object.

func (*SuperAgent) AddCookie added in v0.2.2

func (s *SuperAgent) AddCookie(c *http.Cookie) *SuperAgent

AddCookie adds a cookie to the request. The behavior is the same as AddCookie on Request from net/http

func (*SuperAgent) AddCookies added in v0.2.9

func (s *SuperAgent) AddCookies(cookies []*http.Cookie) *SuperAgent

AddCookies is a convenient method to add multiple cookies

func (*SuperAgent) ClearSuperAgent

func (s *SuperAgent) ClearSuperAgent()

Clear SuperAgent data for another new request.

func (*SuperAgent) Delete added in v0.2.0

func (s *SuperAgent) Delete(targetUrl string) *SuperAgent

func (*SuperAgent) End

func (s *SuperAgent) End(callback ...func(response Response, body string, errs []error)) (Response, string, []error)

End is the most important function that you need to call when ending the chain. The request won't proceed without calling it. End function returns Response which matchs the structure of Response type in Golang's http package (but without Body data). The body data itself returns as a string in a 2nd return value. Lastly but worth noticing, error array (NOTE: not just single error value) is returned as a 3rd value and nil otherwise.

For example:

resp, body, errs := gorequest.New().Get("http://www.google.com").End()
if (errs != nil) {
fmt.Println(resp, body)

Moreover, End function also supports callback which you can put as a parameter. This extends the flexibility and makes GoRequest fun and clean! You can use GoRequest in whatever style you love!

For example:

func printBody(resp gorequest.Response, body string, errs []error){

func (*SuperAgent) EndBytes added in v0.2.6

func (s *SuperAgent) EndBytes(callback ...func(response Response, body []byte, errs []error)) (Response, []byte, []error)

EndBytes should be used when you want the body as bytes. The callbacks work the same way as with `End`, except that a byte array is used instead of a string.

func (*SuperAgent) Get

func (s *SuperAgent) Get(targetUrl string) *SuperAgent

func (*SuperAgent) Head added in v0.2.0

func (s *SuperAgent) Head(targetUrl string) *SuperAgent

func (*SuperAgent) Param added in v0.2.9

func (s *SuperAgent) Param(key string, value string) *SuperAgent

As Go conventions accepts ; as a synonym for &. (https://github.com/golang/go/issues/2210) Thus, Query won't accept ; in a querystring if we provide something like fields=f1;f2;f3 This Param is then created as an alternative method to solve this.

func (*SuperAgent) Patch added in v0.2.3

func (s *SuperAgent) Patch(targetUrl string) *SuperAgent

func (*SuperAgent) Post

func (s *SuperAgent) Post(targetUrl string) *SuperAgent

func (*SuperAgent) Proxy added in v0.2.0

func (s *SuperAgent) Proxy(proxyUrl string) *SuperAgent

Proxy function accepts a proxy url string to setup proxy url for any request. It provides a convenience way to setup proxy which have advantages over usual old ways. One example is you might try to set `http_proxy` environment. This means you are setting proxy up for all the requests. You will not be able to send different request with different proxy unless you change your `http_proxy` environment again. Another example is using Golang proxy setting. This is normal prefer way to do but too verbase compared to GoRequest's Proxy:


To set no_proxy, just put empty string to Proxy func:


func (*SuperAgent) Put added in v0.2.0

func (s *SuperAgent) Put(targetUrl string) *SuperAgent

func (*SuperAgent) Query

func (s *SuperAgent) Query(content interface{}) *SuperAgent

Query function accepts either json string or strings which will form a query-string in url of GET method or body of POST method. For example, making "/search?query=bicycle&size=50x50&weight=20kg" using GET method:

  Query(`{ query: 'bicycle' }`).
  Query(`{ size: '50x50' }`).
  Query(`{ weight: '20kg' }`).

Or you can put multiple json values:

  Query(`{ query: 'bicycle', size: '50x50', weight: '20kg' }`).

Strings are also acceptable:


Or even Mixed! :)

  Query(`{ size: '50x50', weight:'20kg' }`).

func (*SuperAgent) RedirectPolicy

func (s *SuperAgent) RedirectPolicy(policy func(req Request, via []Request) error) *SuperAgent

func (*SuperAgent) Send

func (s *SuperAgent) Send(content interface{}) *SuperAgent

Send function accepts either json string or query strings which is usually used to assign data to POST or PUT method. Without specifying any type, if you give Send with json data, you are doing requesting in json format:

  Send(`{ query: 'sushi' }`).

While if you use at least one of querystring, GoRequest understands and automatically set the Content-Type to `application/x-www-form-urlencoded`


So, if you want to strictly send json format, you need to use Type func to set it as `json` (Please see more details in Type function). You can also do multiple chain of Send:

  Send(`{ wheel: '4'}`).

From v0.2.0, Send function provide another convenience way to work with Struct type. You can mix and match it with json and query string:

type BrowserVersionSupport struct {
  Chrome string
  Firefox string
ver := BrowserVersionSupport{ Chrome: "37.0.2041.6", Firefox: "30.0" }

If you have set Type to text or Content-Type to text/plain, content will be sent as raw string in body instead of form

  Send("hello world").

func (*SuperAgent) SendSlice added in v0.2.11

func (s *SuperAgent) SendSlice(content []interface{}) *SuperAgent

SendSlice (similar to SendString) returns SuperAgent's itself for any next chain and takes content []interface{} as a parameter. Its duty is to append slice of interface{} into s.SliceData ([]interface{}) which later changes into json array in the End() func.

func (*SuperAgent) SendString added in v0.2.0

func (s *SuperAgent) SendString(content string) *SuperAgent

SendString returns SuperAgent's itself for any next chain and takes content string as a parameter. Its duty is to transform String into s.Data (map[string]interface{}) which later changes into appropriate format such as json, form, text, etc. in the End func. Send implicitly uses SendString and you should use Send instead of this.

func (*SuperAgent) SendStruct added in v0.2.11

func (s *SuperAgent) SendStruct(content interface{}) *SuperAgent

SendStruct (similar to SendString) returns SuperAgent's itself for any next chain and takes content interface{} as a parameter. Its duty is to transfrom interface{} (implicitly always a struct) into s.Data (map[string]interface{}) which later changes into appropriate format such as json, form, text, etc. in the End() func.

func (*SuperAgent) Set

func (s *SuperAgent) Set(param string, value string) *SuperAgent

Set is used for setting header fields. Example. To set `Accept` as `application/json`

  Set("Accept", "application/json").

func (*SuperAgent) SetBasicAuth added in v0.2.5

func (s *SuperAgent) SetBasicAuth(username string, password string) *SuperAgent

SetBasicAuth sets the basic authentication header Example. To set the header for username "myuser" and password "mypass"

  SetBasicAuth("myuser", "mypass").

func (*SuperAgent) SetCurlCommand added in v0.2.12

func (s *SuperAgent) SetCurlCommand(enable bool) *SuperAgent

Enable the curlcommand mode which display a CURL command line

func (*SuperAgent) SetDebug added in v0.2.8

func (s *SuperAgent) SetDebug(enable bool) *SuperAgent

Enable the debug mode which logs request/response detail

func (*SuperAgent) SetLogger added in v0.2.8

func (s *SuperAgent) SetLogger(logger *log.Logger) *SuperAgent

func (*SuperAgent) TLSClientConfig added in v0.2.2

func (s *SuperAgent) TLSClientConfig(config *tls.Config) *SuperAgent

Set TLSClientConfig for underling Transport. One example is you can use it to disable security check (https):

gorequest.New().TLSClientConfig(&tls.Config{ InsecureSkipVerify: true}).

func (*SuperAgent) Timeout added in v0.2.0

func (s *SuperAgent) Timeout(timeout time.Duration) *SuperAgent

func (*SuperAgent) Type

func (s *SuperAgent) Type(typeStr string) *SuperAgent

Type is a convenience function to specify the data type to send. For example, to send data as `application/x-www-form-urlencoded` :

  Send(`{ name: "egg benedict", category: "brunch" }`).

This will POST the body "name=egg benedict&category=brunch" to url /recipe

GoRequest supports

"text/html" uses "html"
"application/json" uses "json"
"application/xml" uses "xml"
"text/plain" uses "text"
"application/x-www-form-urlencoded" uses "urlencoded", "form" or "form-data"

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL