Step by Step Guide to Building a Hubspot Marketing Hub API Integration in Go

Introduction

Hey there, fellow Go enthusiast! Ready to dive into the world of Hubspot Marketing Hub API integration? You're in for a treat. This guide will walk you through the process of building a robust integration that'll make your marketing automation dreams come true. Let's get cracking!

Prerequisites

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

• Go installed on your machine (you're a Go dev, so I'm sure you've got this sorted)
• A Hubspot account with API access (if you don't have one, go grab it!)
• Your favorite code editor (VSCode, GoLand, or whatever floats your boat)

Setting up the project

Let's kick things off by setting up our project:

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

Now, let's grab the packages we'll need:

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

Authentication

Alright, time to get cozy with Hubspot's API. Head over to your Hubspot account and snag your API key. We'll use this for authentication.

Create a config.yaml file in your project root:

hubspot:
  api_key: YOUR_API_KEY_HERE

Now, let's read this config in our Go code:

package main

import (
	"fmt"
	"github.com/spf13/viper"
)

func main() {
	viper.SetConfigName("config")
	viper.SetConfigType("yaml")
	viper.AddConfigPath(".")
	err := viper.ReadInConfig()
	if err != nil {
		panic(fmt.Errorf("fatal error config file: %w", err))
	}

	apiKey := viper.GetString("hubspot.api_key")
	fmt.Printf("API Key: %s\n", apiKey)
}

Making API requests

Time to get our hands dirty with some actual API calls. We'll use the resty library to make our lives easier:

package main

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

func main() {
	// ... config loading code ...

	client := resty.New()
	resp, err := client.R().
		SetQueryParam("hapikey", apiKey).
		Get("https://api.hubapi.com/contacts/v1/lists/all/contacts/all")

	if err != nil {
		panic(err)
	}

	fmt.Println(resp.String())
}

Implementing key Hubspot Marketing Hub API endpoints

Now that we've got the basics down, let's implement some key endpoints. We'll focus on Contacts, Lists, Email, and Forms APIs.

Here's a quick example for the Contacts API:

func getContacts(client *resty.Client, apiKey string) {
	resp, err := client.R().
		SetQueryParam("hapikey", apiKey).
		Get("https://api.hubapi.com/contacts/v1/lists/all/contacts/all")

	if err != nil {
		panic(err)
	}

	fmt.Println(resp.String())
}

Error handling and rate limiting

Don't forget to handle those pesky errors and respect Hubspot's rate limits. Here's a simple way to add some basic error handling:

if resp.StatusCode() != 200 {
	fmt.Printf("Error: %s\n", resp.String())
	return
}

For rate limiting, you might want to implement a simple sleep between requests:

time.Sleep(100 * time.Millisecond)

Data parsing and manipulation

Let's parse that JSON response into something useful:

type Contact struct {
	Vid      int    `json:"vid"`
	Email    string `json:"email"`
	Firstname string `json:"firstname"`
	Lastname  string `json:"lastname"`
}

var result map[string]interface{}
err = json.Unmarshal(resp.Body(), &result)
if err != nil {
	panic(err)
}

contacts := result["contacts"].([]interface{})
for _, c := range contacts {
	contact := c.(map[string]interface{})
	fmt.Printf("Name: %s %s, Email: %s\n", 
		contact["properties"].(map[string]interface{})["firstname"].(map[string]interface{})["value"],
		contact["properties"].(map[string]interface{})["lastname"].(map[string]interface{})["value"],
		contact["properties"].(map[string]interface{})["email"].(map[string]interface{})["value"])
}

Building a simple CLI tool

Let's wrap this up in a neat CLI package:

package main

import (
	"flag"
	"fmt"
	// ... other imports ...
)

func main() {
	action := flag.String("action", "contacts", "API action to perform")
	flag.Parse()

	// ... config and client setup ...

	switch *action {
	case "contacts":
		getContacts(client, apiKey)
	case "lists":
		getLists(client, apiKey)
	// ... other cases ...
	default:
		fmt.Println("Unknown action")
	}
}

Testing the integration

Don't forget to test your code! Here's a simple test for our getContacts function:

func TestGetContacts(t *testing.T) {
	client := resty.New()
	apiKey := "test_api_key"

	// Mock the API response
	httpmock.ActivateNonDefault(client.GetClient())
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder("GET", "https://api.hubapi.com/contacts/v1/lists/all/contacts/all",
		httpmock.NewStringResponder(200, `{"contacts": [{"vid": 1, "properties": {"email": {"value": "[email protected]"}}}]}`))

	getContacts(client, apiKey)

	// Add assertions here
}

Best practices and optimization

Remember to implement caching for frequently accessed data and use goroutines for concurrent requests when appropriate. Here's a quick example of using a goroutine:

go func() {
	getContacts(client, apiKey)
}()

Conclusion

And there you have it! You've just built a Hubspot Marketing Hub API integration in Go. Pretty cool, right? Remember, this is just scratching the surface. There's a whole world of Hubspot API endpoints out there waiting for you to explore.

Keep coding, keep learning, and most importantly, have fun with it! If you get stuck, don't forget to check out Hubspot's excellent API documentation. Happy coding!