Step by Step Guide to Building a Hotjar API Integration in Go

Aug 2, 2024 • 6 minute read

Introduction

Hey there, fellow developer! Ready to dive into the world of Hotjar API integration with Go? Awesome! Hotjar's powerful analytics tools can give you incredible insights into user behavior, and with Go's efficiency, we're about to create a killer combination. Let's get started!

Prerequisites

Before we jump in, make sure you've got:

Go installed on your machine (you're a Go dev, so I'm sure you're covered!)
A Hotjar account with API credentials (if you don't have one, go grab it real quick)

Setting up the project

Alright, let's kick things off:

mkdir hotjar-go-integration
cd hotjar-go-integration
go mod init github.com/yourusername/hotjar-go-integration

We'll need a few dependencies. Let's grab them:

go get github.com/go-resty/resty/v2

Authentication

Hotjar uses API keys for authentication. Head over to your Hotjar account, grab that API key, and let's put it to work:

package main

import (
    "github.com/go-resty/resty/v2"
)

const (
    baseURL = "https://api.hotjar.com/v1"
    apiKey  = "your-api-key-here"
)

func main() {
    client := resty.New()
    client.SetHeader("Authorization", "Bearer "+apiKey)
    // We'll use this client for all our requests
}

Making API requests

Now, let's make our first request! We'll fetch a list of heatmaps:

resp, err := client.R().
    SetQueryParam("site_id", "your-site-id").
    Get(baseURL + "/heatmaps")

if err != nil {
    log.Fatalf("Error making request: %v", err)
}

fmt.Println(resp.String())

Parsing and processing data

Great! Now let's make sense of that data:

type Heatmap struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    State string `json:"state"`
}

var heatmaps []Heatmap
err = json.Unmarshal(resp.Body(), &heatmaps)
if err != nil {
    log.Fatalf("Error unmarshaling JSON: %v", err)
}

for _, heatmap := range heatmaps {
    fmt.Printf("Heatmap: %s (ID: %s, State: %s)\n", heatmap.Name, heatmap.ID, heatmap.State)
}

Error handling and rate limiting

Let's be good API citizens and handle errors gracefully:

if resp.StatusCode() != 200 {
    log.Fatalf("API error: %s", resp.Status())
}

// Respect rate limits
time.Sleep(time.Second)

Building a simple CLI tool

Time to wrap this up in a neat CLI package:

package main

import (
    "flag"
    "fmt"
)

func main() {
    siteID := flag.String("site", "", "Hotjar Site ID")
    flag.Parse()

    if *siteID == "" {
        fmt.Println("Please provide a site ID with -site flag")
        return
    }

    // Use the siteID in your API calls
    // ...
}

Advanced features (optional)

Want to take it further? Consider implementing:

Pagination for large datasets
Caching responses to reduce API calls
Concurrent requests for faster data retrieval

Testing the integration

Don't forget to test! Here's a simple example:

func TestGetHeatmaps(t *testing.T) {
    heatmaps, err := getHeatmaps("your-test-site-id")
    if err != nil {
        t.Fatalf("Error getting heatmaps: %v", err)
    }
    if len(heatmaps) == 0 {
        t.Error("No heatmaps returned")
    }
}

Conclusion

And there you have it! You've just built a Hotjar API integration in Go. Pretty cool, right? This is just the beginning - you can extend this to fetch recordings, polls, or whatever Hotjar data you need. The sky's the limit!

Resources

Now go forth and analyze that user data like a boss! Happy coding!