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

Jul 17, 2024 • 7 minute read

Hey there, fellow Go enthusiast! Ready to dive into the world of HubSpot API integration? Buckle up, because we're about to embark on a journey that'll have you wielding the power of HubSpot's API with Go in no time. We'll be using the awesome github.com/clarkmcc/go-hubspot package to make our lives easier. Let's get cracking!

Prerequisites

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

Go installed on your machine (you're a Go dev, right?)
A HubSpot account with an API key (if you don't have one, go grab it!)
A basic understanding of Go and API concepts (but don't worry, we'll keep it simple)

Setting Up the Project

First things first, let's set up our project:

mkdir hubspot-integration
cd hubspot-integration
go mod init hubspot-integration

Now, let's bring in our secret weapon:

go get github.com/clarkmcc/go-hubspot

Initializing the HubSpot Client

Time to get our hands dirty! Let's create a new file called main.go and start cooking:

package main

import (
    "context"
    "fmt"
    "github.com/clarkmcc/go-hubspot"
)

func main() {
    client := hubspot.NewClient("YOUR_API_KEY_HERE")
    
    // We'll be adding more code here soon!
}

Replace YOUR_API_KEY_HERE with your actual HubSpot API key. Don't worry, we won't tell anyone!

Implementing Key API Operations

Contacts API

Let's start with creating a contact:

contact, err := client.CRM().Contacts().Create(context.Background(), hubspot.ContactCreateRequest{
    Properties: map[string]string{
        "email":      "[email protected]",
        "firstname":  "John",
        "lastname":   "Doe",
    },
})
if err != nil {
    fmt.Printf("Error creating contact: %s\n", err)
    return
}
fmt.Printf("Created contact with ID: %s\n", contact.ID)

Retrieving contacts is just as easy:

contacts, err := client.CRM().Contacts().List(context.Background(), hubspot.ListOptions{})
if err != nil {
    fmt.Printf("Error listing contacts: %s\n", err)
    return
}
for _, contact := range contacts.Results {
    fmt.Printf("Contact: %s %s\n", contact.Properties["firstname"], contact.Properties["lastname"])
}

Companies API

Creating a company? Piece of cake:

company, err := client.CRM().Companies().Create(context.Background(), hubspot.CompanyCreateRequest{
    Properties: map[string]string{
        "name": "Awesome Inc.",
        "domain": "awesome.com",
    },
})
if err != nil {
    fmt.Printf("Error creating company: %s\n", err)
    return
}
fmt.Printf("Created company with ID: %s\n", company.ID)

Deals API

Let's create a deal and update its status:

deal, err := client.CRM().Deals().Create(context.Background(), hubspot.DealCreateRequest{
    Properties: map[string]string{
        "dealname": "Big Sale",
        "amount": "1000000",
    },
})
if err != nil {
    fmt.Printf("Error creating deal: %s\n", err)
    return
}
fmt.Printf("Created deal with ID: %s\n", deal.ID)

// Update deal status
_, err = client.CRM().Deals().Update(context.Background(), deal.ID, hubspot.DealUpdateRequest{
    Properties: map[string]string{
        "dealstage": "closedwon",
    },
})
if err != nil {
    fmt.Printf("Error updating deal: %s\n", err)
    return
}
fmt.Println("Deal updated successfully!")

Error Handling and Best Practices

Always check for errors and handle them gracefully. The go-hubspot package takes care of rate limiting for you, but it's good to be aware of it.

For logging, consider using a package like log or logrus for more structured logs.

Testing the Integration

Testing is crucial! Here's a quick example of how you might test the contact creation:

func TestCreateContact(t *testing.T) {
    client := hubspot.NewClient("YOUR_TEST_API_KEY")
    contact, err := client.CRM().Contacts().Create(context.Background(), hubspot.ContactCreateRequest{
        Properties: map[string]string{
            "email": "[email protected]",
            "firstname": "Test",
            "lastname": "User",
        },
    })
    if err != nil {
        t.Fatalf("Error creating contact: %s", err)
    }
    if contact.ID == "" {
        t.Fatal("Expected contact ID to be non-empty")
    }
}

For more complex scenarios, consider mocking the API responses using a package like httptest.

Wrapping Up

And there you have it! You've just built a HubSpot API integration in Go. Pretty cool, right? We've covered the basics of working with contacts, companies, and deals, but there's so much more you can do. Why not explore other endpoints or dive deeper into the go-hubspot package documentation?

Remember, the key to mastering any API integration is practice and curiosity. So keep coding, keep exploring, and most importantly, have fun with it!

Resources

Now go forth and integrate with confidence! Happy coding!