Building a REST API in Go? You’ve probably heard of Gin. It’s the most popular HTTP web framework in the Go ecosystem, and for good reason. Fast routing, simple middleware, and an API that just makes sense.

Let me show you why Gin might be the right choice for your next project.

What Makes Gin Different?

Gin uses httprouter under the hood. This gives it blazing fast performance. The router uses a radix tree structure, which means route lookups are incredibly efficient.

But performance isn’t everything. Gin also provides a clean, intuitive API. If you’ve used Express.js or Flask, you’ll feel right at home.

Here’s a basic server:

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{
			"message": "pong",
		})
	})

	r.Run(":8080")
}

That’s it. A working API in under 20 lines.

Middleware: Where Gin Shines

Middleware in Gin is straightforward. You write a function that takes *gin.Context and calls c.Next() to continue the chain.

Here’s a simple logging middleware:

func RequestLogger() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		path := c.Request.URL.Path

		// Process request
		c.Next()

		// Log after request completes
		latency := time.Since(start)
		status := c.Writer.Status()

		log.Printf("[%d] %s %s - %v", status, c.Request.Method, path, latency)
	}
}

func main() {
	r := gin.New() // No default middleware
	r.Use(RequestLogger())
	r.Use(gin.Recovery()) // Recover from panics

	// Routes here...
}

The gin.Default() function gives you logging and recovery middleware for free. But you can start fresh with gin.New() and add only what you need.

This pattern is similar to how context works in Go - data flows through the chain, and each handler can inspect or modify it.

Route Groups and Versioning

Real APIs need structure. Gin’s route groups make this easy:

func main() {
	r := gin.Default()

	// Public routes
	public := r.Group("/api/v1")
	{
		public.GET("/health", healthCheck)
		public.POST("/login", login)
	}

	// Protected routes
	protected := r.Group("/api/v1")
	protected.Use(AuthMiddleware())
	{
		protected.GET("/users", listUsers)
		protected.POST("/users", createUser)
		protected.GET("/users/:id", getUser)
		protected.PUT("/users/:id", updateUser)
		protected.DELETE("/users/:id", deleteUser)
	}

	r.Run(":8080")
}

func getUser(c *gin.Context) {
	id := c.Param("id")
	
	// Fetch user from database...
	user := fetchUser(id)
	if user == nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
		return
	}

	c.JSON(http.StatusOK, user)
}

Notice how the :id parameter is extracted with c.Param("id"). Clean and simple.

Request Binding and Validation

Gin handles JSON binding with built-in validation:

type CreateUserRequest struct {
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=8"`
	Name     string `json:"name" binding:"required"`
}

func createUser(c *gin.Context) {
	var req CreateUserRequest

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// req is now validated and ready to use
	user := User{
		Email: req.Email,
		Name:  req.Name,
	}

	// Save to database...

	c.JSON(http.StatusCreated, user)
}

The binding tags use go-playground/validator. You get email validation, length checks, and dozens of other validators out of the box.

Common Pitfalls

A few things to watch out for:

Don’t forget to handle errors properly. Always return after sending a response. Otherwise, your code keeps executing.

// Wrong - code continues after error
if err != nil {
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
}
// This still runs!
c.JSON(http.StatusOK, data)

// Right - return after error
if err != nil {
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
c.JSON(http.StatusOK, data)

Be careful with goroutines. If you spawn a goroutine from a handler, copy the context first:

func handler(c *gin.Context) {
	// Copy the context for goroutine use
	cCp := c.Copy()
	go func() {
		// Use cCp, not c
		log.Println(cCp.Request.URL.Path)
	}()

	c.JSON(http.StatusOK, gin.H{"status": "processing"})
}

Should You Use Gin?

Gin excels at building REST APIs. The router is fast. The middleware system is flexible. The API is intuitive.

For simple services, Go’s standard library net/http works fine. But once you need routing, middleware, and request validation, Gin saves you time.

Check out the official Gin documentation for more advanced features like custom validators, file uploads, and HTML rendering.

Give it a try on your next Go project.