DEV Community: Jnanesh D

Httpc - A much needed wrapper

Jnanesh D — Sun, 08 Feb 2026 14:28:40 +0000

Make API Calls in Go Without the Pain

Introducing `httpc` — A Simple, Fluent HTTP Client Wrapper for Go

If you’ve ever worked with APIs in Go, you’ve probably felt the same thing most Go developers do:

“Why does something as simple as calling an API and parsing JSON feel so verbose?”

Go’s standard net/http, encoding/json, and related packages are solid — but when you combine them for real-world API clients, the code often gets repetitive, boilerplate-heavy, and harder to maintain than it needs to be.

To fix that, I built httpc — a small wrapper over the default Go HTTP client that makes everyday API tasks simple, expressive, and ergonomic while staying close to Go’s philosophy. ([Go Packages][1])

Why We Need Something Better

With the standard library, even a simple JSON API call looks like this:

create a request
set headers
send the request
read the response
close the body
unmarshal JSON
handle errors

…and that’s before you add timeouts, retries, auth, or anything else.

This is great for building blocks — but not great when you just want to call an API and get things done.

httpc hides most of that boilerplate so you can focus on the logic your app actually cares about.

What `httpc` Gives You

httpc is designed around a few simple principles:
✔ Fluent & Chainable API
✔ Sensible defaults out-of-the-box
✔ Simple for beginners, powerful for pros
✔ Support for retries, timeouts, rate limiting, circuit breakers
✔ Easy JSON encoding/decoding
✔ Middleware support
✔ Testing tools like mock servers ([Go Packages][1])

Let’s look at how this changes your day-to-day code.

Quick Start — Making Requests

Simple GET

Instead of all the typical setup, you can write:

resp, err := httpc.New().
    Get("https://api.example.com/users").
    Do()
if err != nil {
    log.Fatal(err)
}
defer resp.Close()

fmt.Println(resp.Status())

That’s it. No manual request building. No manual body closing. ([Go Packages][1])

POST with JSON

Sending a struct as JSON and making a POST is literally just:

user := User{Name: "John", Email: "john@example.com"}

resp, err := httpc.New().
    Post("https://api.example.com/users").
    JSON(user).
    Do()

No json.Marshal first. No setting "Content-Type" manually. ([Go Packages][1])

Get JSON Directly as a Struct

Want to decode the response into a struct in one step?

var users []User
err := httpc.New().
    Get("https://api.example.com/users").
    DecodeJSON(&users)

The response is parsed and unmarshaled for you. ([Go Packages][1])

Important Features That Save Time

Headers & Query Parameters

client := httpc.New().
    WithBaseURL("https://api.example.com").
    WithHeader("Accept", "application/json")

resp, _ := client.Get("/users").
    Query("page", "1").
    Query("limit", "10").
    Do()

Note how WithBaseURL makes relative URLs easy. ([Go Packages][1])

Timeouts & Custom Clients

You can set timeouts at the client or per-request level:

client := httpc.New().WithTimeout(30 * time.Second)

resp, _ := client.Get("/slow-endpoint").
    Timeout(60 * time.Second).
    Do()

No more juggling contexts manually unless you want to. ([Go Packages][1])

Resilience: Retries, Circuit Breakers, Rate Limiting

If you care about real-world API reliability:

client := httpc.New().
    WithRetry(3, time.Second).
    WithCircuitBreaker(5, time.Minute).
    WithRateLimiter(10)

You get automatic retries with exponential backoff, circuit breakers, and rate control. ([Go Packages][1])

Testing Made Easy

Testing API clients can be hard. httpc includes a mock server utility so you can write tests like:

server := mock.NewServer()
defer server.Close()

server.OnGet("/users/1").
    Status(200).
    JSON(User{ID: 1, Name: "John"}).
    Reply()

client := httpc.New().WithBaseURL(server.URL())
var user User

err := client.Get("/users/1").DecodeJSON(&user)

No external APIs needed — just fast, reliable tests. ([Go Packages][2])

Final Thoughts

Go’s standard library is powerful, but it’s also minimal by design. That means for anything beyond trivial use, you end up writing a lot of repetitive code.

httpc keeps what’s good about Go’s ecosystem — simplicity, clarity, composability — while reducing the boilerplate around common HTTP and JSON tasks.

If you build clients, microservices, or backend integrations in Go, this tool can save you time and make your code easier to read and maintain.

👉 Check out the docs: https://pkg.go.dev/github.com/jnaneshd/httpc

Context in go, why it matters

Jnanesh D — Sat, 10 Jan 2026 06:55:27 +0000

Understanding Context in Go: A Beginner's Guide

What is Context?

Context is Go's way of managing cancellations, timeouts, and request-scoped values across goroutines. Since Go is not an object-oriented language, you might find context the closest way of dealing with attributes attached to a particular flow of data.

📊 The Context Hierarchy

context.Background()  (root)
    │
    ├─ WithTimeout ──→ Auto-cancels after duration
    │
    ├─ WithCancel ──→ Manual cancellation
    │
    ├─ WithDeadline ──→ Cancels at specific time
    │
    └─ WithValue ──→ Carries request data

Creating Contexts: Practical Examples

1️⃣ Background Context (Starting Point)

func main() {
    ctx := context.Background()
    processRequest(ctx)
}

Output: Root context with no deadline or values

2️⃣ WithTimeout (Auto-Cancel)

package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"
)

func SimpleRandom(donn chan bool) {
    // First we will take a random number
    randomNum := rand.Intn(100) > 50
    if !randomNum {
        time.Sleep(50 * time.Second)
    }
    time.Sleep(time.Second)
    donn <- true
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()
    chann := make(chan bool)
    go SimpleRandom(chann)

    select {
    case <-chann:
        fmt.Println("Ok we got the output within the deadline")

    case <-ctx.Done():
        fmt.Println("Timed out! No more waiting")
    }
}

Let's say you are handling a CPU intensive task which takes random amount of time. Since we cannot wait indefinitely, we can use WithTimeout and wait for either channel or the context to timeout.

Output:

Ok we got the output within the deadline OR
Timed out! No more waiting

Use cases: OS operations, waiting for HTTP requests, and more.

Note: Always perform defer cancel() so that any memory leaks are avoided and cleanup happens carefully.

Use Case 2: Cancellable DB Query

Suppose we are connecting to a database in our code and the database is taking a lot of time. In that scenario also, context tells the connector to exit after a certain time.

func searchUsers(ctx context.Context, name string) ([]User, error) {
    query := "SELECT id, name, email FROM users WHERE name LIKE ?"

    rows, err := db.QueryContext(ctx, query, "%"+name+"%")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
            return nil, err
        }
        users = append(users, u)
    }

    return users, nil
}

// Usage with timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

users, err := searchUsers(ctx, "John")

Use Case 4: Request Pipeline with Tracing

When we are dealing with webserver handlers, we often find the same data being fetched in different places to achieve our goals. To solve this, we can use the WithValue of the context to store some variables.

In the above code, the Auth handler attaches the userId to the context and the subsequent pipeline executions can utilize the same instead of querying back.

Final Verdict

✅ You can use context to manage the lifecycle of goroutines, prevent hangs, and enforce deadlines.

✅ You can also use it to pass data to the chain of execution flows, primarily in middleware.

❌ Never store anything that is not request scoped in the context.

Happy coding! 🚀