How to Integrate HubSpot API to Manage Contacts in Python

Setup Environment

• Ensure you have Python installed on your system. You will also need the `requests` and `json` libraries, which help in making HTTP requests and handling JSON data, respectively. You can install these dependencies using pip:

pip install requests

Authentication with HubSpot API

• HubSpot API requires authentication. You can use an API Key or OAuth. For simplicity, we'll cover API Key usage here. Replace `'your_api_key'` with your actual HubSpot API Key.
• Store the API Key safely, avoiding hardcoding it directly into your scripts.
• Here's a quick way to authenticate your requests:

import requests

API_KEY = 'your_api_key'
# For example purpose, using Contacts endpoint
BASE_URL = f"https://api.hubapi.com/contacts/v1/lists/all/contacts/all?hapikey={API_KEY}"

Making Requests to HubSpot API

• To interact with HubSpot Contacts, you will primarily perform CRUD operations: Create, Read, Update, and Delete.
• Below is how you can make a GET request to retrieve contacts:

response = requests.get(BASE_URL)
if response.status_code == 200:
    contacts = response.json()
    for contact in contacts['contacts']:
        print(f"Contact ID: {contact['vid']} Name: {contact['properties']['firstname']['value']}")

else:
    print("Failed to retrieve contacts")

Create a New Contact

• To add a new contact, you need to send a POST request with the contact's details in JSON format.
• Here's how to add a new contact named FirstName and LastName:

def create_contact(first_name, last_name, email):
    url = f"https://api.hubapi.com/contacts/v1/contact?hapikey={API_KEY}"
    headers = {'Content-Type': 'application/json'}
    data = {
        "properties": [
            {"property": "email", "value": email},
            {"property": "firstname", "value": first_name},
            {"property": "lastname", "value": last_name}
        ]
    }

    response = requests.post(url, json=data, headers=headers)
    return response.json()

new_contact = create_contact("FirstName", "LastName", "email@example.com")
print(new_contact)

Update an Existing Contact

• To update a contact, issue a POST request to the specific contact URL with the updated data.
• Here's an example of how to update an existing contact's email:

def update_contact(contact_id, new_email):
    url = f"https://api.hubapi.com/contacts/v1/contact/vid/{contact_id}/profile?hapikey={API_KEY}"
    headers = {'Content-Type': 'application/json'}
    data = {
        "properties": [
            {"property": "email", "value": new_email}
        ]
    }

    response = requests.post(url, json=data, headers=headers)
    return response.json()

updated_contact = update_contact(contact_id=123, new_email="newemail@example.com")
print(updated_contact)

Delete a Contact

• If you need to delete a contact, you will need to send a DELETE request to the contact's endpoint.
• Below is the code to delete a contact using their VID:

def delete_contact(contact_id):
    url = f"https://api.hubapi.com/contacts/v1/contact/vid/{contact_id}?hapikey={API_KEY}"

    response = requests.delete(url)
    return response.status_code

delete_status = delete_contact(contact_id=123)
print(f"Delete status: {delete_status}")

Rate Limiting and Error Handling

• HubSpot APIs are rate-limited. Incorporate logic to handle rate limits and retries.
• Check response codes and include error handling as shown below:

try:
    response = requests.get(BASE_URL)
    response.raise_for_status()  # Raises an HTTPError for bad responses
    # Handle successful response
    contacts = response.json()
except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
except Exception as err:
    print(f"Other error occurred: {err}")

Best Practices

• Always handle API keys and sensitive information securely, avoiding hard-coded values in your scripts.
• Use environment variables or configuration files to manage API keys.
• Implement logging for better monitoring and error tracking.
• In production applications, consider using a library like `backoff` to manage rate-limits and retries.