Bento Golang Guide

To initialize the Bento client, you'll need your Site UUID, Publishable Key, and Secret Key from your Bento account. You can find your keys in your Bento Team. To see your keys click Your Private API Keys Button and if do you do not see a Publishable key and Secret Key, click on Generate Key to create a set.

Client configuration

import (
  "time"
  bento "github.com/bentonow/bento-golang-sdk"
)

// Initialize the Bento client
config := &bento.Config{
  PublishableKey: "your_publishable_key",
  SecretKey:      "your_secret_key",
  SiteUUID:       "your_site_uuid",
  Timeout:        10 * time.Second, // Optional, defaults to 10s
}

client, err := bento.NewClient(config)
if err != nil {
  // Handle error
}

Beginner Guide

Tracking Your First Event

Events represent specific actions users take within your application. Tracking these actions provides valuable insights into user behavior patterns and engagement.

Streamlined Subscriber Management

We recommend using Events as the preferred method to add subscribers, as they simultaneously initiate workflows and automations in a single operation.

Powerful Data Enrichment

Events excel at capturing contextual information alongside user actions. This can be used in emails via liquid tags or in segmentation. For instance, when recording a purchase event, you can include detailed transaction information such as:

Detail	Liquid tag
Product details
Purchase amount
Transaction ID
Payment method

Practical Example

When a customer completes a purchase, you can track this as an event while including all relevant purchase details. This approach enables you to:

Trigger specific post-purchase workflows
Launch targeted follow-up automations
Track lifetime value (LTV) metrics
Create personalized communications based on purchase history

Track a simple page view

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$pageView",
        Email: "[email protected]",
        Details: map[string]interface{}{
          "url":   "/home",
          "title": "Home Page",
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Track a form submission

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$formSubmitted",
        Email: "[email protected]",
        Details: map[string]interface{}{
          "formName": "Newsletter Signup",
          "source":   "Homepage",
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Managing Subscribers

If you need to manage subscribers directly there are a set of convenience methods available to you. Add, update, and unsubscribe subscribers with these simple methods. Currently, you cannot remove subscribers via the API, but you can remove them from the dashboard People > All Users.

Create a new subscriber

CreateSubscriber()

/v1/batch/subscribers

    input := &bento.SubscriberInput{
      Email: "[email protected]",
    }

    subscriber, err := client.CreateSubscriber(ctx, input)
    if err != nil {
      // Handle error
    }

Adding Individual Subscribers

Please note, while these methods make it easy to manage a subscriber, the Bento recommended way to add a subscriber is via an event. This allows you to kick off sequences and automations, while also recording the "event" at the same time (1 API call).

Adding Multiple Subscribers

Importing or modifying multiple subscribers should be handled via the bulk methods, instead of looping over these calls multiple times.

Common Use Cases

Here are some common scenarios with ready-to-use code:

Tracking a user login "Event"

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$login",
        Email: "[email protected]",
        Details: map[string]interface{}{
          "method": "password",
          "device": "mobile",
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Intermediate Guide

Custom Fields and Tags

Bento allows you to store custom data about your users through fields and segment them with tags:

Create a new custom field definition

CreateField()

/v1/fetch/fields

    fieldKey := "membershipLevel"
    field, err := client.CreateField(ctx, fieldKey)
    if err != nil {
      // Handle error
    }

Using Custom Fields & Tags

While custom fields and tags can be used to segment subscribers, most Bento users find that namespaced tags provide a more effective and easier-to-maintain solution for most segmentation use cases.

Namespaced Tags

Namespaced tags follow this format: namespace:detail For example, if you offer three subscription plans, you could create these tags:

subscription:basic
subscription:pro
subscription:enterprise

We recommend applying these tags either through an automated flow or via bulk updates.

Tags do not need to be namespaced, but for many customers the organization pays off by using namespaced tags when it makes sense.

Fields

Fields are perfect for storing information about your subscribers, such as their language, timezone, or other relevant details. By using fields, you can easily segment subscribers based on their specific needs and preferences, allowing you to tailor your marketing efforts and messaging to each group.

The primary difference between fields and namespaced tags is that fields are not limited to a specific detail and do not need to be predefined. You can store any type of data in a field, including strings, numbers, or even objects. This flexibility makes fields a powerful tool for storing data.

Best Practices

For optimal organization, consider using tags for segmentation while storing more detailed user information in custom fields. Many successful implementations use a strategic combination of both approaches.

Tracking Purchase Events

When recording purchase events, you must include a unique: key as part of the tracking data. This requirement prevents duplicate transactions from being recorded in your analytics.

Most users find it beneficial to use their internal cart or order number as the unique: key. This approach simplifies future lookups and maintains consistency across your systems. The unique: key value you provide is accessible through liquid tags when creating custom email templates, allowing for personalized transactional messaging based on specific purchase details.

Tracking purchases is a great way to monitor customer lifetime value (LTV) and identify recurring customers. Bento reports on the LTV of each subscriber, allowing you to identify high-value customers and tailor your marketing efforts accordingly.

Track a purchase event to monitor customer lifetime value

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$purchase",
        Email: "[email protected]",
        Details: map[string]interface{}{
          "unique": map[string]interface{}{
            "key": "order-123", // Unique order identifier
          },
          "value": map[string]interface{}{
            "amount":   9999, // Amount in cents
            "currency": "USD",
          },
          "cart": map[string]interface{}{
            "items": []map[string]interface{}{
              {
                "product_id":    "prod-456",
                "product_name":  "Premium Widget",
                "product_price": 9999,
                "quantity":      1,
                "product_sku":   "SKU-456",
              },
            },
          },
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Advanced Guide

Batch Operations

For efficiency, we suggest using batch operations when integrating with Bento. These methods allow for single or bulk operations on subscribers and events, improving the performance and scalability of your integration. They also cover more than 80% of the API use cases for most customers.

Import multiple subscribers at once

ImportSubscribers()

/v1/batch/subscribers

    subscribers := []*bento.SubscriberInput{
      {
        Email:     "[email protected]",
        FirstName: "Alice",
        Fields: map[string]interface{}{
          "company": "Acme Inc",
        },
      },
      {
        Email:     "[email protected]",
        FirstName: "Bob",
        Fields: map[string]interface{}{
          "company": "Beta Corp",
        },
      },
      // Can add up to 1,000 subscribers in a single batch
    }

    err := client.ImportSubscribers(ctx, subscribers)
    if err != nil {
      // Handle error
    }

Import multiple events at once

trackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$login",
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "date": "2023-01-01",
        },
      },
      {
        Type:  "$purchase",
        Email: "[email protected]",
        Details: map[string]interface{}{
          "unique": map[string]interface{}{
            "key": "order-123",
          },
          "value": map[string]interface{}{
            "currency": "USD",
            "amount":   9999,
          },
        },
      },
      // Can add up to 1,000 events in a single batch
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Transactional Emails

Bento allows you to send personalized transactional emails for time-sensitive, direct communications. These emails serve specific functional purposes rather than marketing objectives.

Ideal Transactional Email Use Cases

User onboarding (confirmation etc)
Password reset notifications
Sign-in verification links
Order confirmations and details
Account notifications

From Address Requirements

The sender address used in your transactional emails must be configured as an Author email within your Bento settings. Please note that generic addresses such as "~~[email protected]~~" or similar non-personal addresses are not currently supported.

Important Distinction

Transactional emails are designed for essential communications that facilitate specific user actions or provide critical information.

Transactional emails should not be used as substitutes for marketing campaigns or promotional content.

Send a transactional email

CreateEmails()

/v1/batch/emails

    emails := []bento.EmailData{
      {
        To:            "[email protected]",
        From:          "[email protected]",
        Subject:       "Reset Password",
        HTMLBody:      "<p>Here is a link to reset your password ... {{ link }}</p>",
        Transactional: true,
        Personalizations: map[string]interface{}{
          "link": "https://example.com/reset-password",
        },
      },
    }

    results, err := client.CreateEmails(ctx, emails)
    if err != nil {
      // Handle error
    }

    fmt.Printf("Successfully queued %d emails for delivery\n", results)

Subscriber Updates

Many organizations joining Bento already have an established subscriber base that requires bulk updates over time. These updates commonly include setting field data and managing tags across multiple subscribers. We firmly believe that these methods are the best way to manage a single or multiple subscribers, and we recommend using them for all subscriber updates.

These methods cover more than 80% of the API use cases for most customers.

Choosing the Right Update Method:

The SDK offers multiple approaches for creating subscribers in Bento, each suited to different scenarios.

Preferred Method: Events

The recommended way to create subscribers is via events in response to user activity. This approach activates automations, workflows, and can contain data enrichment.

Create a subscriber when they sign up

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$subscribe",
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "firstName":    "Jane",
          "lastName":     "Doe",
          "signupSource": "website",
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Alternative Methods

For scenarios where you need to create subscribers independently of user actions:

Single Subscriber Creation

Use this method when you need to quickly create a single subscriber with minimal data:

Create a single subscriber (email only)

CreateSubscriber()

/v1/fetch/subscribers

    input := &bento.SubscriberInput{
      Email: "[email protected]",
    }

    subscriber, err := client.CreateSubscriber(ctx, input)
    if err != nil {
      // Handle error
    }

This endpoint is rate-limited and not suitable for loops or bulk creation. Use only for individual subscriber creation.

Multiple Or Enriched Subscriber Creation

For creating multiple subscribers or including additional fields:

Import multiple subscribers

ImportSubscribers()

/v1/batch/subscribers

    subscribers := []*bento.SubscriberInput{
      {
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "membershipTier":   "gold",
          "accountStatus":    "active",
          "lastRenewalDate":  time.Now().Format(time.RFC3339),
        },
      },
      {
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "membershipTier": "silver",
          "accountStatus":  "pending",
          "trialEndsAt":    time.Now().Add(30 * 24 * time.Hour).Format(time.RFC3339),
        },
      },
    }

    err := client.ImportSubscribers(ctx, subscribers)
    if err != nil {
        // Handle error
    }

Best Practices for Batch Imports:

Though the API supports up to 1,000 subscribers per call, we recommend batches of 200-300 for optimal performance when dealing with extensive data.
Include all relevant custom fields in the initial import to minimize follow-up updates.
For very large imports (10,000+ subscribers), consider implementing a queue system with delay between batches.

Updating Subscribers

Depending on your requirements, several approaches are available for updating subscriber information.

Event-Based Updates (Preferred)

When updates occur in response to user actions, tracking events is the recommended approach:

Update subscriber when they update their profile

TrackEvent()

/v1/batch/events

    events := []bento.EventData{
      {
        Type:  "$subscription_change",
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "subscriptionTier": "premium",
        },
      },
    }

    err := client.TrackEvent(ctx, events)
    if err != nil {
      // Handle error
    }

Becuase you can apply as many changes via automations / workflows as you want this is the most flexible method. It doesn't require code or deployment changes, and can be completely handled in Bento.

Alternative Update Methods

For updates outside of user-triggered actions:

Single Attribute Updates

For quickly updating a specific attribute on a single subscriber:

Add or update a single field

ImportSubscribers()

/v1/batch/subscribers

    subscribers := []*bento.SubscriberInput{
      {
        Email:     "[email protected]",
        FirstName: "Jesse",
        LastName:  "Bento",
        Tags:      []string{"membership:premium"},
        RemoveTags: []string{"membership:silver"},
        Fields: map[string]interface{}{
          "membershipTier": "premium",
          "accountStatus":  "pending",
          "trialEndsAt":    time.Now().Add(30 * 24 * time.Hour).Format(time.RFC3339),
        },
      },
    }

    err := client.ImportSubscribers(ctx, subscribers)
    if err != nil {
      // Handle error
    }

The Command API is not recommended for multiple updates or bulk operations. Given its heavy rate limit, use the Batch API instead.

Batch Updates

For updating multiple subscribers or multiple fields at once, use the batch import method:

Update multiple subscribers

ImportSubscribers()

/v1/batch/subscribers

    subscribers := []*bento.SubscriberInput{
      {
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "membershipTier":  "gold",
          "accountStatus":   "active",
          "lastRenewalDate": time.Now().Format(time.RFC3339),
        },
      },
      {
        Email: "[email protected]",
        Fields: map[string]interface{}{
          "membershipTier": "silver",
          "accountStatus":  "pending",
          "trialEndsAt":    time.Now().Add(30 * 24 * time.Hour).Format(time.RFC3339),
        },
      },
    }

    err := client.ImportSubscribers(ctx, subscribers)
    if err != nil {
      // Handle error
    }

Recommendations:

Even for single-subscriber updates, consider using the batch import method when multiple fields need updating.
The batch import performs an "upsert" operation – it creates subscribers that don't exist and updates those that do.
This approach provides the most flexibility as your use cases evolve, whether you need to add more changes or modify multiple users simultaneously.

Specialized Update Operations

For specific update scenarios, the SDK offers dedicated methods:

Change a subscribers email address

SubscriberCommand()

/v1/fetch/commands

    commands := []bento.CommandData{
      {
        Command: bento.CommandChangeEmail,
        Email:   "[email protected]",
        Query:   "[email protected]",
      },
    }

    err := client.SubscriberCommand(ctx, commands)
    if err != nil {
      // Handle error
    }

Utility Features

These features provide additional convenience utility for Bento users, to handle some of the common secondary use cases we commonly see, such as validation and blacklist checks.

Email validation

ValidateEmail()

/v1/experimental/validation

    data := &bento.ValidationData{
      EmailAddress: "[email protected]",
      FullName:     "John Doe",        // Optional
      UserAgent:    "Mozilla/5.0...",  // Optional
      IPAddress:    "192.168.1.1",     // Optional
    }

    validationResult, err := client.ValidateEmail(ctx, data)
    if err != nil {
      // Handle error
    }

    fmt.Printf("Email is valid: %v\n", validationResult.Valid)

API Reference

Core API

Client - Main entry point for using the SDK (bento.Client)
Configuration - Set up through the bento.Config struct with API keys and settings
Context Support - All API operations accept a Go context for cancellation and timeout control
Data Types - Structured request/response types in the root package (bento.EventData, bento.SubscriberInput, etc.)
Error Handling - Predefined error types (ErrInvalidConfig, ErrInvalidEmail, etc.) for specialized error handling

Convenience Methods

Core API

Use Case	Go SDK Method
Add a new subscriber
Unsubscribe a subscriber
Update data for an existing subscriber
Add a tag to a subscriber
Update subscriber fields
Track a custom event
Track a purchase event

Modules

Batch

Use Case	Method	API Reference
Import multiple subscribers		Import Subscribers >>
Import multiple events		Import Events >>
Send emails		Send Emails >>

Commands

Use Case	Method	API Reference
Add a tag		Subscriber Upsert >>
Remove a tag		Subscriber Upsert >>
Add a field		Subscriber Upsert >>
Remove a field		Subscriber Upsert >>
Subscribe a user		Subscriber Command >>
Unsubscribe a user		Subscriber Command >>
Change email address		Subscriber Command >>

Experimental

Use Case	Method	API Reference
Validate email address		Validate Email >>
Predict gender from name		Gender Guess >>
Get IP geolocation		IP Geolocation >>
Check domain/IP blacklist		Blacklist Check >>

Fields

Use Case	Method	API Reference
Get all fields		Get Fields >>
Create a field		Create Fields >>

Subscribers

Use Case	Method	API Reference
Find subscriber		Find Subscriber >>
Create a subscriber		Create Subscriber >>
Run commands		Subscriber Commands >>

Use Case	Method	API Reference
Get all tags		List Tags >>
Create a tag		Create Tag >>

Common Errors


Not Authorized	Check your API keys and ensure they have appropriate permissions
Rate Limited	Implement backoff/retry logic for batch operations
Network Errors	Check internet connectivity and API endpoint availability
Exceptions	Double check you are using a valid `Author` & the payload format.

Debugging Tips


1.	Enable `logErrors: true` in your configuration for detailed error logging
2.	Use try/catch blocks around API calls to handle errors gracefully
3.	For batch operations, start with smaller batches to isolate issues

FAQ

Bento Golang Guide

Reference

Using Go Get

Client configuration

Streamlined Subscriber Management

Powerful Data Enrichment

Practical Example

Track a simple page view

Track a form submission

Create a new subscriber

Adding Individual Subscribers

Adding Multiple Subscribers

Tracking a user login "Event"

Create a new custom field definition

Namespaced Tags

Fields

Best Practices

Track a purchase event to monitor customer lifetime value

Import multiple subscribers at once

Import multiple events at once

Ideal Transactional Email Use Cases

From Address Requirements

Important Distinction

Send a transactional email

Choosing the Right Update Method:

Preferred Method: Events

Create a subscriber when they sign up

Alternative Methods

Create a single subscriber (email only)

Import multiple subscribers

Updating Subscribers

Event-Based Updates (Preferred)

Update subscriber when they update their profile

Alternative Update Methods

Add or update a single field

Update multiple subscribers

Specialized Update Operations

Change a subscribers email address

Email validation

Core API

Convenience Methods

Core API

Modules

Batch

Commands

Experimental

Fields

Subscribers

Tags

Common Errors

Debugging Tips

Can I use this SDK in a frontend environment?

How do I handle rate limiting?

What's the maximum batch size for importing subscribers or events?

How do I track anonymous users?

Which Go versions are supported?

How can I contribute to the SDK?

How do I handle contexts and cancellation?

Can I use the SDK with AWS Lambda or other serverless environments?