intercom

package module
v2.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 9, 2026 License: Apache-2.0 Imports: 6 Imported by: 0

README

Intercom-Go

Thin client for the Intercom API (v2.15).

Install

go get github.com/karnott/intercom-go/v2

Usage

Getting a Client
import (
	intercom "github.com/karnott/intercom-go/v2"
)

ic := intercom.NewClient("your_access_token")

This client can then be used to make requests.

You can find your access token here. Learn more about access tokens here.

If you are building a third party application you can get your OAuth token by setting up OAuth for Intercom.

Client Options

The client can be configured with different options by calls to ic.Option:

ic.Option(intercom.TraceHTTP(true)) // turn http tracing on
ic.Option(intercom.BaseURI("http://intercom.dev")) // change the base uri used, useful for testing
ic.Option(intercom.SetHTTPClient(myHTTPClient)) // set a new HTTP client, see below for more info

or combined:

ic.Option(intercom.TraceHTTP(true), intercom.BaseURI("http://intercom.dev"))
Contacts

Since API v2.0, Users and Leads have been unified into a single Contact model. A Contact has a role field that is either "user" or "lead".

Create
contact := intercom.Contact{
	Role:  "user",
	ExternalID: "27",
	Email: "test@example.com",
	Name:  "InterGopher",
	SignedUpAt: int64(time.Now().Unix()),
	CustomAttributes: map[string]interface{}{"is_cool": true},
}
savedContact, err := ic.Contacts.Create(&contact)
Update
contact := intercom.Contact{
	ID:   "6329e838deab13e266c3602d",
	Name: "Updated Name",
	CustomAttributes: map[string]interface{}{"is_cool": true},
}
savedContact, err := ic.Contacts.Update(&contact)
  • ID is required for updates.
Find
contact, err := ic.Contacts.FindByID("6329e838deab13e266c3602d")

contact, err := ic.Contacts.FindByExternalID("27")
List
contactList, err := ic.Contacts.List(intercom.PageParams{Page: 1, PerPage: 50})
contactList.Pages    // CursorPages with cursor-based pagination
contactList.Contacts // []Contact

contactList, err := ic.Contacts.ListByEmail("test@example.com", intercom.PageParams{})
Merge

Merge a source contact into a target contact:

mergedContact, err := ic.Contacts.Merge("source_contact_id", "target_contact_id")
Archive / Unarchive / Delete
contact, err := ic.Contacts.Archive("6329e838deab13e266c3602d")
contact, err := ic.Contacts.Unarchive("6329e838deab13e266c3602d")
contact, err := ic.Contacts.Delete("6329e838deab13e266c3602d")
Adding/Removing Companies

Adding a Company:

companyList := intercom.CompanyList{
	Companies: []intercom.Company{
		{CompanyID: "5"},
	},
}
contact := intercom.Contact{
	ID: "6329e838deab13e266c3602d",
	Companies: &companyList,
}

Removing is similar, but adding a Remove: intercom.Bool(true) attribute to a company.

Companies
Save
company := intercom.Company{
	CompanyID: "27",
	Name: "My Co",
	CustomAttributes: map[string]interface{}{"is_cool": true},
	Plan: &intercom.Plan{Name: "MyPlan"},
}
savedCompany, err := ic.Companies.Save(&company)
  • CompanyID is required.
Find
company, err := ic.Companies.FindByID("46adad3f09126dca")

company, err := ic.Companies.FindByCompanyID("27")

company, err := ic.Companies.FindByName("My Co")
List
companyList, err := ic.Companies.List(intercom.PageParams{Page: 2})
companyList.Pages     // page information
companyList.Companies // []Company

companyList, err := ic.Companies.ListBySegment("segmentID123", intercom.PageParams{})

companyList, err := ic.Companies.ListByTag("42", intercom.PageParams{})
List Contacts
contactList, err := ic.Companies.ListContactsByID("46adad3f09126dca", intercom.PageParams{})
contactList.Contacts // []Contact

contactList, err := ic.Companies.ListContactsByCompanyID("27", intercom.PageParams{})
Events
Save
event := intercom.Event{
	UserID: "27",
	EventName: "bought_item",
	CreatedAt: int64(time.Now().Unix()),
	Metadata: map[string]interface{}{"item_name": "PocketWatch"},
}
err := ic.Events.Save(&event)
  • One of UserID, ID, or Email is required.
  • EventName is required.
  • CreatedAt is optional, must be an integer representing seconds since Unix Epoch. Will be set to now unless given.
  • Metadata is optional, and can be constructed as a map[string]interface{}.
Admins
List
adminList, err := ic.Admins.List()
admins := adminList.Admins
Tags
List
tagList, err := ic.Tags.List()
tags := tagList.Tags
Save
tag := intercom.Tag{Name: "GoTag"}
savedTag, err := ic.Tags.Save(&tag)

Name is required. Passing an ID will attempt to update the tag with that ID.

Delete
err := ic.Tags.Delete("6")
Tagging Contacts/Companies
taggingList := intercom.TaggingList{Name: "GoTag", Users: []intercom.Tagging{{UserID: "27"}}}
savedTag, err := ic.Tags.Tag(&taggingList)

A Tagging can identify a Contact or Company, and can be set to Untag:

taggingList := intercom.TaggingList{Name: "GoTag", Users: []intercom.Tagging{{UserID: "27", Untag: intercom.Bool(true)}}}
savedTag, err := ic.Tags.Tag(&taggingList)
Segments
List
segmentList, err := ic.Segments.List()
segments := segmentList.Segments
Find
segment, err := ic.Segments.Find("abc312daf2397")
Messages
New Admin to Contact Email
msg := intercom.NewEmailMessage(intercom.PERSONAL_TEMPLATE, &intercom.Admin{ID: "1234"}, &intercom.Contact{Email: "test@example.com"}, "subject", "body")
savedMessage, err := ic.Messages.Save(&msg)

Can use intercom.PLAIN_TEMPLATE too.

New Admin to Contact InApp
msg := intercom.NewInAppMessage(&intercom.Admin{ID: "1234"}, &intercom.Contact{Email: "test@example.com"}, "body")
savedMessage, err := ic.Messages.Save(&msg)
New Contact Message
msg := intercom.NewContactMessage(&intercom.Contact{Email: "test@example.com"}, "body")
savedMessage, err := ic.Messages.Save(&msg)
Conversations
Find Conversation
convo, err := ic.Conversations.Find("1234")
List Conversations

All:

convoList, err := ic.Conversations.ListAll(intercom.PageParams{})

By Contact:

convoList, err := ic.Conversations.ListByContact(&contact, intercom.SHOW_ALL, intercom.PageParams{})
convoList, err := ic.Conversations.ListByContact(&contact, intercom.SHOW_UNREAD, intercom.PageParams{})

By Admin:

convoList, err := ic.Conversations.ListByAdmin(&admin, intercom.SHOW_ALL, intercom.PageParams{})
convoList, err := ic.Conversations.ListByAdmin(&admin, intercom.SHOW_OPEN, intercom.PageParams{})
convoList, err := ic.Conversations.ListByAdmin(&admin, intercom.SHOW_CLOSED, intercom.PageParams{})
Reply

Contact reply:

convo, err := ic.Conversations.Reply("1234", &contact, intercom.CONVERSATION_COMMENT, "my message")

Contact reply with attachment:

convo, err := ic.Conversations.ReplyWithAttachmentURLs("1234", &contact, intercom.CONVERSATION_COMMENT, "my message", []string{"http://www.example.com/attachment.jpg"})

Admin reply:

convo, err := ic.Conversations.Reply("1234", &admin, intercom.CONVERSATION_COMMENT, "my message")

Admin note:

convo, err := ic.Conversations.Reply("1234", &admin, intercom.CONVERSATION_NOTE, "my message to just admins")
Open and Close
convo, err := ic.Conversations.Open("1234", &openerAdmin)
convo, err := ic.Conversations.Close("1234", &closerAdmin)
Assign
convo, err := ic.Conversations.Assign("1234", &assignerAdmin, &assigneeAdmin)
Articles
List
articleList, err := ic.Articles.List(intercom.PageParams{Page: 1, PerPage: 50})
articleList.Articles // []Article
Find
article, err := ic.Articles.Find("123")
Collections

Collections support hierarchical nesting via ParentID. Top-level collections have a nil ParentID; sub-collections (formerly "sections" in API < v2.10) have a ParentID pointing to their parent collection.

List
collectionList, err := ic.Collections.List(intercom.PageParams{Page: 1, PerPage: 50})
collectionList.Collections // []Collection
Find
collection, err := ic.Collections.Find("123")
Webhooks / Notifications

If you have received a JSON webhook notification, you can convert it into Intercom objects. A Notification can be created from any io.Reader, typically an http request body:

notif, err := intercom.NewNotification(r)

The returned Notification will contain exactly 1 of the Company, Conversation, Event, Tag or Contact fields populated. It may only contain partial objects depending on what is provided by the webhook.

Errors

Errors returned from the API implement intercom.IntercomError and can be checked:

_, err := ic.Contacts.FindByID("doesnotexist")
if herr, ok := err.(intercom.IntercomError); ok && herr.GetCode() == "not_found" {
	fmt.Print(herr)
}
HTTP Client

The HTTP Client used by this package can be swapped out for one of your choosing, with your own configuration, it just needs to implement the HTTPClient interface:

type HTTPClient interface {
	Get(string, interface{}) ([]byte, error)
	Post(string, interface{}) ([]byte, error)
	Patch(string, interface{}) ([]byte, error)
	Delete(string, interface{}) ([]byte, error)
}

It'll need to work with accessToken and baseURI values. See the provided client for an example. Then create an Intercom Client and inject the HTTPClient:

ic := intercom.Client{}
ic.Option(intercom.SetHTTPClient(myHTTPClient))
// ready to go!
On Bools

Due to the way Go represents the zero value for a bool, it's necessary to pass pointers to bool instead in some places.

The helper intercom.Bool(true) creates these for you.

Documentation

Overview

Package intercom-go provides a thin client for the Intercom API: http://developers.intercom.com/reference.

The first step to using Intercom's Go client is to create a client object, using your Access Token from your [settings](http://app.intercom.io/apps/api_keys). 

import (
  "github.com/karnott/intercom-go/v2"
)
ic := intercom.NewClient("myAccessToken")

The client can be configured with different options by calls to Option: 

ic.Option(intercom.TraceHTTP(true)) // turn http tracing on
ic.Option(intercom.BaseURI("http://intercom.dev")) // change the base uri used, useful for testing
ic.Option(intercom.SetHTTPClient(myHTTPClient)) // set a new HTTP client

Errors

Errors may be returned from some calls. Errors returned from the API will implement `intercom.IntercomError` and can be checked: 

_, err := ic.Contacts.FindByEmail("doesnotexist@intercom.io")
if herr, ok := err.(intercom.IntercomError); ok && herr.GetCode() == "not_found" {
  fmt.Print(herr)
}

HTTP Client

The HTTP Client used by this package can be swapped out for one of your choosing, with your own configuration, it just needs to implement the HTTPClient interface: 

type HTTPClient interface {
  Get(string, interface{}) ([]byte, error)
  Post(string, interface{}) ([]byte, error)
  Patch(string, interface{}) ([]byte, error)
  Delete(string, interface{}) ([]byte, error)
}

The client will probably need to work with `accessToken` and `baseURI` values. See the provided client for an example. Then create an Intercom Client and inject the HTTPClient: 

ic := intercom.Client{}
ic.Option(intercom.SetHTTPClient(myHTTPClient))
// ready to go!

On Bools

Due to the way Go represents the zero value for a bool, it's necessary to pass pointers to bool instead in some places. The helper `intercom.Bool(true)` creates these for you.

Pagination

For many resources, pagination should be applied through the use of a PageParams object passed into List() functions. 

pageParams := PageParams{
  Page: 2,
  PerPage: 10,
}
ic.Contacts.List(pageParams)

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BaseURI 

func BaseURI(baseURI string) option

BaseURI sets a base URI for the HTTP Client to use. Defaults to "https://api.intercom.io". Typically this would be used during testing to point to a stubbed service.

func Bool 

func Bool(value bool) *bool

Bool is a helper method to create *bool. *bool is preferred to bool because it allows distinction between false and absence.

func SetHTTPClient 

func SetHTTPClient(httpClient interfaces.HTTPClient) option

SetHTTPClient sets a HTTPClient for the Intercom Client to use. Useful for customising timeout behaviour etc.

func TraceHTTP 

func TraceHTTP(trace bool) option

TraceHTTP turns on HTTP request/response tracing for debugging.

Types

type Admin 

type Admin struct {
	ID                json.Number            `json:"id"`
	Type              string                 `json:"type"`
	Name              string                 `json:"name"`
	Email             string                 `json:"email"`
	Avatar            *AdminAvatar           `json:"avatar,omitempty"`
	TeamPriorityLevel map[string]interface{} `json:"team_priority_level,omitempty"`
}

Admin represents an Admin in Intercom.

func (Admin) IsNobodyAdmin 

func (a Admin) IsNobodyAdmin() bool

IsNobodyAdmin is a helper function to determine if the Admin is 'Nobody'.

func (Admin) MessageAddress 

func (a Admin) MessageAddress() MessageAddress

MessageAddress gets the address for a Contact in order to message them

func (Admin) String 

func (a Admin) String() string

type AdminAPI 

type AdminAPI struct {
	// contains filtered or unexported fields
}

AdminAPI implements AdminRepository

type AdminAvatar 

type AdminAvatar struct {
	ImageURL string `json:"image_url,omitempty"`
}

AdminAvatar represents an admin's avatar.

type AdminList 

type AdminList struct {
	Admins []Admin
}

AdminList represents an object holding list of Admins

type AdminRepository 

type AdminRepository interface {
	// contains filtered or unexported methods
}

AdminRepository defines the interface for working with Admins through the API.

type AdminService 

type AdminService struct {
	Repository AdminRepository
}

AdminService handles interactions with the API through an AdminRepository.

func (*AdminService) List 

func (c *AdminService) List() (AdminList, error)

List lists the Admins associated with your App.

type Article 

type Article struct {
	ID          string            `json:"id,omitempty"`
	Type        string            `json:"type,omitempty"`
	WorkspaceID string            `json:"workspace_id,omitempty"`
	Title       string            `json:"title,omitempty"`
	Description string            `json:"description,omitempty"`
	Body        string            `json:"body,omitempty"`
	AuthorID    int64             `json:"author_id,omitempty"`
	State       string            `json:"state,omitempty"`
	CreatedAt   int64             `json:"created_at,omitempty"`
	UpdatedAt   int64             `json:"updated_at,omitempty"`
	URL         string            `json:"url,omitempty"`
	ParentID    int64             `json:"parent_id,omitempty"`
	ParentType  string            `json:"parent_type,omitempty"`
	ParentIDs   []int64           `json:"parent_ids,omitempty"`
	Statistics  ArticleStatistics `json:"statistics,omitempty"`
}

Article represents a Help Center Article in Intercom.

func (Article) String 

func (a Article) String() string

type ArticleAPI 

type ArticleAPI struct {
	// contains filtered or unexported fields
}

ArticleAPI implements ArticleRepository

type ArticleList 

type ArticleList struct {
	Pages      PageParams `json:"pages,omitempty"`
	TotalCount int64      `json:"total_count,omitempty"`
	Articles   []Article  `json:"data,omitempty"`
}

ArticleList holds a list of Articles and pagination info.

type ArticleRepository 

type ArticleRepository interface {
	// contains filtered or unexported methods
}

ArticleRepository defines the interface for working with Articles through the API.

type ArticleService 

type ArticleService struct {
	Repository ArticleRepository
}

ArticleService handles interactions with the API through an ArticleRepository.

func (*ArticleService) Find 

func (s *ArticleService) Find(id string) (Article, error)

Find a particular Article by ID.

func (*ArticleService) List 

func (s *ArticleService) List(params PageParams) (ArticleList, error)

List all Articles for the App.

type ArticleStatistics 

type ArticleStatistics struct {
	Views                     int64   `json:"views,omitempty"`
	Conversations             int64   `json:"conversations,omitempty"`
	Reactions                 int64   `json:"reactions,omitempty"`
	HappyReactionPercentage   float64 `json:"happy_reaction_percentage,omitempty"`
	NeutralReactionPercentage float64 `json:"neutral_reaction_percentage,omitempty"`
	SadReactionPercentage     float64 `json:"sad_reaction_percentage,omitempty"`
}

ArticleStatistics holds metrics for an Article.

type Client 

type Client struct {
	// Services for interacting with various resources in Intercom.
	Admins        AdminService
	Articles      ArticleService
	Collections   CollectionService
	Companies     CompanyService
	Contacts      ContactService
	Conversations ConversationService
	Events        EventService
	Jobs          JobService
	Messages      MessageService
	Segments      SegmentService
	Tags          TagService

	// Mappings for resources to API constructs
	AdminRepository        AdminRepository
	ArticleRepository      ArticleRepository
	CollectionRepository   CollectionRepository
	CompanyRepository      CompanyRepository
	ContactRepository      ContactRepository
	ConversationRepository ConversationRepository
	EventRepository        EventRepository
	JobRepository          JobRepository
	MessageRepository      MessageRepository
	SegmentRepository      SegmentRepository
	TagRepository          TagRepository

	// AccessToken for Intercom's API (Bearer token).
	AccessToken string

	// HTTP Client used to interact with the API.
	HTTPClient interfaces.HTTPClient
	// contains filtered or unexported fields
}

A Client manages interacting with the Intercom API.

func NewClient 

func NewClient(accessToken string) *Client

NewClient returns a new Intercom API client, configured with the default HTTPClient.

func NewClientWithHTTPClient 

func NewClientWithHTTPClient(accessToken string, httpClient interfaces.HTTPClient) *Client

NewClientWithHTTPClient returns a new Intercom API client, configured with the supplied HTTPClient interface.

func (*Client) Option 

func (c *Client) Option(opts ...option) (previous option)

Option sets Options on the Intercom Client, see TraceHTTP, BaseURI and SetHTTPClient.

type Collection 

type Collection struct {
	ID          string  `json:"id,omitempty"`
	Type        string  `json:"type,omitempty"`
	WorkspaceID string  `json:"workspace_id,omitempty"`
	Name        string  `json:"name,omitempty"`
	Description string  `json:"description,omitempty"`
	CreatedAt   int64   `json:"created_at,omitempty"`
	UpdatedAt   int64   `json:"updated_at,omitempty"`
	URL         string  `json:"url,omitempty"`
	Icon        string  `json:"icon,omitempty"`
	Order       int64   `json:"order,omitempty"`
	ParentID    *string `json:"parent_id"`
}

Collection represents a Help Center Collection in Intercom.

func (Collection) String 

func (c Collection) String() string

type CollectionAPI 

type CollectionAPI struct {
	// contains filtered or unexported fields
}

CollectionAPI implements CollectionRepository

type CollectionList 

type CollectionList struct {
	Pages       PageParams   `json:"pages,omitempty"`
	TotalCount  int64        `json:"total_count,omitempty"`
	Collections []Collection `json:"data,omitempty"`
}

CollectionList holds a list of Collections and pagination info.

type CollectionRepository 

type CollectionRepository interface {
	// contains filtered or unexported methods
}

CollectionRepository defines the interface for working with Collections through the API.

type CollectionService 

type CollectionService struct {
	Repository CollectionRepository
}

CollectionService handles interactions with the API through a CollectionRepository.

func (*CollectionService) Find 

func (s *CollectionService) Find(id string) (Collection, error)

Find a particular Collection by ID.

func (*CollectionService) List 

func (s *CollectionService) List(params PageParams) (CollectionList, error)

List all Collections for the App.

type Company 

type Company struct {
	ID               string                 `json:"id,omitempty"`
	CompanyID        string                 `json:"company_id,omitempty"`
	Name             string                 `json:"name,omitempty"`
	RemoteCreatedAt  int64                  `json:"remote_created_at,omitempty"`
	LastRequestAt    int64                  `json:"last_request_at,omitempty"`
	CreatedAt        int64                  `json:"created_at,omitempty"`
	UpdatedAt        int64                  `json:"updated_at,omitempty"`
	SessionCount     int64                  `json:"session_count,omitempty"`
	MonthlySpend     int64                  `json:"monthly_spend"`
	UserCount        int64                  `json:"user_count,omitempty"`
	Size             int64                  `json:"size,omitempty"`
	Website          string                 `json:"website,omitempty"`
	Industry         string                 `json:"industry,omitempty"`
	Tags             *TagList               `json:"tags,omitempty"`
	Segments         *SegmentList           `json:"segments,omitempty"`
	Plan             *Plan                  `json:"plan,omitempty"`
	CustomAttributes map[string]interface{} `json:"custom_attributes,omitempty"`
	Remove           *bool                  `json:"-"`
}

Company represents a Company in Intercom Not all of the fields are writeable to the API, non-writeable fields are stripped out from the request. Please see the API documentation for details.

func (Company) String 

func (c Company) String() string

type CompanyAPI 

type CompanyAPI struct {
	// contains filtered or unexported fields
}

CompanyAPI implements CompanyRepository

type CompanyIdentifiers 

type CompanyIdentifiers struct {
	ID        string `url:"-"`
	CompanyID string `url:"company_id,omitempty"`
	Name      string `url:"name,omitempty"`
}

CompanyIdentifiers to identify a Company using the API

type CompanyList 

type CompanyList struct {
	Pages     PageParams
	Companies []Company
}

CompanyList holds a list of Companies and paging information

type CompanyRepository 

type CompanyRepository interface {
	// contains filtered or unexported methods
}

CompanyRepository defines the interface for working with Companies through the API.

type CompanyService 

type CompanyService struct {
	Repository CompanyRepository
}

CompanyService handles interactions with the API through a CompanyRepository.

func (*CompanyService) FindByCompanyID 

func (c *CompanyService) FindByCompanyID(companyID string) (Company, error)

FindByCompanyID finds a Company using their CompanyID CompanyID is a customer-defined field

func (*CompanyService) FindByID 

func (c *CompanyService) FindByID(id string) (Company, error)

FindByID finds a Company using their Intercom ID

func (*CompanyService) FindByName 

func (c *CompanyService) FindByName(name string) (Company, error)

FindByName finds a Company using their Name

func (*CompanyService) List 

func (c *CompanyService) List(params PageParams) (CompanyList, error)

List Companies

func (*CompanyService) ListBySegment 

func (c *CompanyService) ListBySegment(segmentID string, params PageParams) (CompanyList, error)

List Companies by Segment

func (*CompanyService) ListByTag 

func (c *CompanyService) ListByTag(tagID string, params PageParams) (CompanyList, error)

List Companies by Tag

func (*CompanyService) ListContactsByCompanyID 

func (c *CompanyService) ListContactsByCompanyID(companyID string, params PageParams) (ContactList, error)

List Company Contacts by CompanyID

func (*CompanyService) ListContactsByID 

func (c *CompanyService) ListContactsByID(id string, params PageParams) (ContactList, error)

List Company Contacts by ID

func (*CompanyService) Save 

func (c *CompanyService) Save(user *Company) (Company, error)

Save a new Company, or update an existing one.

type Contact 

type Contact struct {
	ID                     string                 `json:"id,omitempty"`
	Type                   string                 `json:"type,omitempty"`
	ExternalID             string                 `json:"external_id,omitempty"`
	Role                   string                 `json:"role,omitempty"`
	Email                  string                 `json:"email,omitempty"`
	EmailDomain            string                 `json:"email_domain,omitempty"`
	Phone                  string                 `json:"phone,omitempty"`
	FormattedPhone         string                 `json:"formatted_phone,omitempty"`
	Name                   string                 `json:"name,omitempty"`
	WorkspaceID            string                 `json:"workspace_id,omitempty"`
	Avatar                 *ContactAvatar         `json:"avatar,omitempty"`
	OwnerID                int64                  `json:"owner_id,omitempty"`
	SocialProfiles         *SocialProfileList     `json:"social_profiles,omitempty"`
	HasHardBounced         bool                   `json:"has_hard_bounced,omitempty"`
	MarkedEmailAsSpam      bool                   `json:"marked_email_as_spam,omitempty"`
	UnsubscribedFromEmails *bool                  `json:"unsubscribed_from_emails,omitempty"`
	CreatedAt              int64                  `json:"created_at,omitempty"`
	UpdatedAt              int64                  `json:"updated_at,omitempty"`
	SignedUpAt             int64                  `json:"signed_up_at,omitempty"`
	LastSeenAt             int64                  `json:"last_seen_at,omitempty"`
	LastRepliedAt          int64                  `json:"last_replied_at,omitempty"`
	LastContactedAt        int64                  `json:"last_contacted_at,omitempty"`
	LastEmailOpenedAt      int64                  `json:"last_email_opened_at,omitempty"`
	LastEmailClickedAt     int64                  `json:"last_email_clicked_at,omitempty"`
	LanguageOverride       string                 `json:"language_override,omitempty"`
	Browser                string                 `json:"browser,omitempty"`
	BrowserVersion         string                 `json:"browser_version,omitempty"`
	BrowserLanguage        string                 `json:"browser_language,omitempty"`
	OS                     string                 `json:"os,omitempty"`
	Tags                   *TagList               `json:"tags,omitempty"`
	Segments               *SegmentList           `json:"segments,omitempty"`
	Companies              *CompanyList           `json:"companies,omitempty"`
	Location               *ContactLocation       `json:"location,omitempty"`
	Referrer               string                 `json:"referrer,omitempty"`
	UTMCampaign            string                 `json:"utm_campaign,omitempty"`
	UTMContent             string                 `json:"utm_content,omitempty"`
	UTMMedium              string                 `json:"utm_medium,omitempty"`
	UTMSource              string                 `json:"utm_source,omitempty"`
	UTMTerm                string                 `json:"utm_term,omitempty"`
	EnabledPushMessaging   *bool                  `json:"enabled_push_messaging,omitempty"`
	CustomAttributes       map[string]interface{} `json:"custom_attributes,omitempty"`
}

Contact represents a Contact (user or lead) within Intercom. Not all of the fields are writeable to the API, non-writeable fields are stripped out from the request. Please see the API documentation for details.

func (Contact) MessageAddress 

func (c Contact) MessageAddress() MessageAddress

MessageAddress gets the address for a Contact in order to message them.

func (Contact) String 

func (c Contact) String() string

type ContactAPI 

type ContactAPI struct {
	// contains filtered or unexported fields
}

ContactAPI implements ContactRepository

type ContactAvatar 

type ContactAvatar struct {
	Type     string `json:"type,omitempty"`
	ImageURL string `json:"image_url,omitempty"`
}

ContactAvatar represents a contact's avatar.

type ContactCompany 

type ContactCompany struct {
	CompanyID string `json:"company_id,omitempty"`
	Name      string `json:"name,omitempty"`
	Remove    *bool  `json:"remove,omitempty"`
}

A ContactCompany represents a Company association for a Contact.

func MakeContactCompaniesFromCompanies 

func MakeContactCompaniesFromCompanies(companies []Company) []ContactCompany

MakeContactCompaniesFromCompanies converts a slice of Companies to ContactCompanies.

func MakeUserCompaniesFromCompanies 

func MakeUserCompaniesFromCompanies(companies []Company) []ContactCompany

MakeUserCompaniesFromCompanies is an alias for MakeContactCompaniesFromCompanies for backwards compatibility.

type ContactIdentifiers 

type ContactIdentifiers struct {
	ID         string `url:"-"`
	ExternalID string `url:"external_id,omitempty"`
}

ContactIdentifiers hold identifiers for finding a Contact.

type ContactList 

type ContactList struct {
	Pages      CursorPages `json:"pages"`
	TotalCount int64       `json:"total_count,omitempty"`
	Contacts   []Contact   `json:"data,omitempty"`
}

ContactList holds a list of Contacts and cursor-based pagination info.

type ContactLocation 

type ContactLocation struct {
	Type          string `json:"type,omitempty"`
	Country       string `json:"country,omitempty"`
	Region        string `json:"region,omitempty"`
	City          string `json:"city,omitempty"`
	CountryCode   string `json:"country_code,omitempty"`
	ContinentCode string `json:"continent_code,omitempty"`
}

ContactLocation holds location data for a contact.

type ContactRepository 

type ContactRepository interface {
	// contains filtered or unexported methods
}

ContactRepository defines the interface for working with Contacts through the API.

type ContactService 

type ContactService struct {
	Repository ContactRepository
}

ContactService handles interactions with the API through a ContactRepository.

func (*ContactService) Archive 

func (c *ContactService) Archive(id string) (Contact, error)

Archive a Contact.

func (*ContactService) Create 

func (c *ContactService) Create(contact *Contact) (Contact, error)

Create Contact.

func (*ContactService) Delete 

func (c *ContactService) Delete(id string) (Contact, error)

Delete Contact permanently.

func (*ContactService) FindByExternalID 

func (c *ContactService) FindByExternalID(externalID string) (Contact, error)

FindByExternalID looks up a Contact by their external ID.

func (*ContactService) FindByID 

func (c *ContactService) FindByID(id string) (Contact, error)

FindByID looks up a Contact by their Intercom ID.

func (*ContactService) List 

func (c *ContactService) List(params PageParams) (ContactList, error)

List all Contacts for App.

func (*ContactService) ListByEmail 

func (c *ContactService) ListByEmail(email string, params PageParams) (ContactList, error)

ListByEmail looks up a list of Contacts by their Email.

func (*ContactService) Merge 

func (c *ContactService) Merge(sourceID, targetID string) (Contact, error)

Merge two Contacts. The source contact is merged into the target.

func (*ContactService) Unarchive 

func (c *ContactService) Unarchive(id string) (Contact, error)

Unarchive a Contact.

func (*ContactService) Update 

func (c *ContactService) Update(contact *Contact) (Contact, error)

Update Contact.

type Conversation 

type Conversation struct {
	ID                  string               `json:"id"`
	Title               string               `json:"title,omitempty"`
	CreatedAt           int64                `json:"created_at"`
	UpdatedAt           int64                `json:"updated_at"`
	WaitingSince        int64                `json:"waiting_since,omitempty"`
	SnoozedUntil        int64                `json:"snoozed_until,omitempty"`
	Contacts            ContactList          `json:"contacts"`
	AdminAssigneeID     int64                `json:"admin_assignee_id,omitempty"`
	TeamAssigneeID      int64                `json:"team_assignee_id,omitempty"`
	State               string               `json:"state,omitempty"`
	Open                bool                 `json:"open"`
	Read                bool                 `json:"read"`
	ConversationMessage ConversationMessage  `json:"conversation_message"`
	ConversationParts   ConversationPartList `json:"conversation_parts"`
	TagList             *TagList             `json:"tags"`
}

A Conversation represents a conversation between contacts and admins in Intercom.

type ConversationAPI 

type ConversationAPI struct {
	// contains filtered or unexported fields
}

ConversationAPI implements ConversationRepository

type ConversationList 

type ConversationList struct {
	Pages         CursorPages    `json:"pages"`
	TotalCount    int64          `json:"total_count,omitempty"`
	Conversations []Conversation `json:"conversations"`
}

ConversationList is a list of Conversations

type ConversationListParams 

type ConversationListParams struct {
	PageParams
	Type           string `url:"type,omitempty"`
	AdminID        string `url:"admin_id,omitempty"`
	IntercomUserID string `url:"intercom_user_id,omitempty"`
	Email          string `url:"email,omitempty"`
	Open           *bool  `url:"open,omitempty"`
	Unread         *bool  `url:"unread,omitempty"`
	DisplayAs      string `url:"display_as,omitempty"`
}

type ConversationListState 

type ConversationListState int

The state of Conversations to query SHOW_ALL shows all conversations, SHOW_OPEN shows only open conversations (only valid for Admin Conversation queries) SHOW_CLOSED shows only closed conversations (only valid for Admin Conversation queries) SHOW_UNREAD shows only unread conversations (only valid for Contact Conversation queries) 

const (
	SHOW_ALL ConversationListState = iota
	SHOW_OPEN
	SHOW_CLOSED
	SHOW_UNREAD
)

type ConversationMessage 

type ConversationMessage struct {
	ID      string         `json:"id"`
	Subject string         `json:"subject"`
	Body    string         `json:"body"`
	Author  MessageAddress `json:"author"`
	URL     string         `json:"url"`
}

A ConversationMessage is the message that started the conversation rendered for presentation

type ConversationPart 

type ConversationPart struct {
	ID         string         `json:"id"`
	PartType   string         `json:"part_type"`
	Body       string         `json:"body"`
	CreatedAt  int64          `json:"created_at"`
	UpdatedAt  int64          `json:"updated_at"`
	NotifiedAt int64          `json:"notified_at"`
	AssignedTo Admin          `json:"assigned_to"`
	Author     MessageAddress `json:"author"`
}

A ConversationPart is a Reply, Note, or Assignment to a Conversation

type ConversationPartList 

type ConversationPartList struct {
	Parts []ConversationPart `json:"conversation_parts"`
}

A ConversationPartList lists the subsequent Conversation Parts

type ConversationRepository 

type ConversationRepository interface {
	// contains filtered or unexported methods
}

ConversationRepository defines the interface for working with Conversations through the API.

type ConversationService 

type ConversationService struct {
	Repository ConversationRepository
}

ConversationService handles interactions with the API through an ConversationRepository.

func (*ConversationService) Assign 

func (c *ConversationService) Assign(id string, assigner, assignee *Admin) (Conversation, error)

Assign a Conversation to an Admin

func (*ConversationService) Close 

func (c *ConversationService) Close(id string, closer *Admin) (Conversation, error)

Close a Conversation (without a body)

func (*ConversationService) Find 

func (c *ConversationService) Find(id string) (Conversation, error)

Find Conversation by conversation id

func (*ConversationService) ListAll 

func (c *ConversationService) ListAll(pageParams PageParams) (ConversationList, error)

List all Conversations

func (*ConversationService) ListByAdmin 

func (c *ConversationService) ListByAdmin(admin *Admin, state ConversationListState, pageParams PageParams) (ConversationList, error)

List Conversations by Admin

func (*ConversationService) ListByContact 

func (c *ConversationService) ListByContact(contact *Contact, state ConversationListState, pageParams PageParams) (ConversationList, error)

List Conversations by Contact

func (*ConversationService) MarkRead 

func (c *ConversationService) MarkRead(id string) (Conversation, error)

Mark Conversation as read (by a Contact)

func (*ConversationService) Open 

func (c *ConversationService) Open(id string, opener *Admin) (Conversation, error)

Open a Conversation (without a body)

func (*ConversationService) Reply 

func (c *ConversationService) Reply(id string, author MessagePerson, replyType ReplyType, body string) (Conversation, error)

func (*ConversationService) ReplyWithAttachmentURLs 

func (c *ConversationService) ReplyWithAttachmentURLs(id string, author MessagePerson, replyType ReplyType, body string, attachmentURLs []string) (Conversation, error)

Reply to a Conversation by id

type CursorPages 

type CursorPages struct {
	Type       string              `json:"type,omitempty"`
	Page       int64               `json:"page,omitempty"`
	PerPage    int64               `json:"per_page,omitempty"`
	TotalPages int64               `json:"total_pages,omitempty"`
	Next       *StartingAfterParam `json:"next,omitempty"`
}

CursorPages holds cursor-based pagination info returned by the API (v2.0+).

type Data 

type Data struct {
	Item json.RawMessage `json:"item,omitempty"`
}

Data is the data node of the notification.

type Event 

type Event struct {
	ID        string                 `json:"id,omitempty"`
	Email     string                 `json:"email,omitempty"`
	UserID    string                 `json:"user_id,omitempty"`
	EventName string                 `json:"event_name,omitempty"`
	CreatedAt int64                  `json:"created_at,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

An Event represents a new event that happens to a User.

func (Event) String 

func (e Event) String() string

type EventAPI 

type EventAPI struct {
	// contains filtered or unexported fields
}

EventAPI implements EventRepository

type EventRepository 

type EventRepository interface {
	// contains filtered or unexported methods
}

EventRepository defines the interface for working with Events through the API.

type EventService 

type EventService struct {
	Repository EventRepository
}

EventService handles interactions with the API through an EventRepository.

func (*EventService) Save 

func (e *EventService) Save(event *Event) error

Save a new Event

type IntercomError 

type IntercomError interface {
	Error() string
	GetStatusCode() int
	GetCode() string
	GetMessage() string
}

IntercomError is a known error from the Intercom API

type JobAPI 

type JobAPI struct {
	// contains filtered or unexported fields
}

JobAPI implements TagRepository

type JobData 

type JobData struct {
	ID string `json:"id,omitempty"`
}

JobData is a payload that can be used to identify an existing Job to append to.

type JobItem 

type JobItem struct {
	Method   string      `json:"method"`
	DataType string      `json:"data_type"`
	Data     interface{} `json:"data"`
}

A JobItem is an item to be processed as part of a bulk Job

func NewContactJobItem 

func NewContactJobItem(contact *Contact, method JobItemMethod) *JobItem

NewContactJobItem creates a JobItem that holds a Contact. It can take either a JOB_POST (for updates) or JOB_DELETE (for deletes) method.

func NewEventJobItem 

func NewEventJobItem(event *Event) *JobItem

NewEventJobItem creates a JobItem that holds an Event.

type JobItemMethod 

type JobItemMethod int
const (
	JOB_POST JobItemMethod = iota
	JOB_DELETE
)

func (JobItemMethod) String 

func (state JobItemMethod) String() string

type JobRepository 

type JobRepository interface {
	// contains filtered or unexported methods
}

JobRepository defines the interface for working with Jobs.

type JobRequest 

type JobRequest struct {
	JobData *JobData   `json:"job,omitempty"`
	Items   []*JobItem `json:"items,omitempty"`
	// contains filtered or unexported fields
}

A JobRequest represents a new job to be sent to Intercom

type JobResponse 

type JobResponse struct {
	ID          string            `json:"id,omitempty"`
	AppID       string            `json:"app_id,omitempty"`
	UpdatedAt   int64             `json:"updated_at,omitempty"`
	CreatedAt   int64             `json:"created_at,omitempty"`
	CompletedAt int64             `json:"completed_at,omitempty"`
	ClosingAt   int64             `json:"closing_at,omitempty"`
	Name        string            `json:"name,omitempty"`
	State       string            `json:"job_state,omitempty"`
	Links       map[string]string `json:"links,omitempty"`
}

A JobResponse represents a job enqueud on Intercom

func (JobResponse) String 

func (j JobResponse) String() string

type JobService 

type JobService struct {
	Repository JobRepository
}

JobService builds jobs to process

func (*JobService) AppendEvents 

func (js *JobService) AppendEvents(id string, items ...*JobItem) (JobResponse, error)

Append Event items to existing Job

func (*JobService) AppendUsers 

func (js *JobService) AppendUsers(id string, items ...*JobItem) (JobResponse, error)

Append User items to existing Job

func (*JobService) Find 

func (js *JobService) Find(id string) (JobResponse, error)

Find existing Job

func (*JobService) NewEventJob 

func (js *JobService) NewEventJob(items ...*JobItem) (JobResponse, error)

NewEventJob creates a new Job for processing Events.

func (*JobService) NewUserJob 

func (js *JobService) NewUserJob(items ...*JobItem) (JobResponse, error)

NewUserJob creates a new Job for processing Users.

type JobState 

type JobState int

The state of a Job 

const (
	PENDING JobState = iota
	RUNNING
	COMPLETED
	FAILED
)

func (JobState) String 

func (state JobState) String() string

type MessageAPI 

type MessageAPI struct {
	// contains filtered or unexported fields
}

MessageAPI implements MessageRepository

type MessageAddress 

type MessageAddress struct {
	Type  string `json:"type,omitempty"`
	ID    string `json:"id,omitempty"`
	Email string `json:"email,omitempty"`
}

type MessagePerson 

type MessagePerson interface {
	MessageAddress() MessageAddress
}

A MessagePerson is someone to send a Message to and from.

type MessageRepository 

type MessageRepository interface {
	// contains filtered or unexported methods
}

MessageRepository defines the interface for creating and updating Messages through the API.

type MessageRequest 

type MessageRequest struct {
	MessageType string         `json:"message_type,omitempty"`
	Subject     string         `json:"subject,omitempty"`
	Body        string         `json:"body,omitempty"`
	Template    string         `json:"template,omitempty"`
	From        MessageAddress `json:"from,omitempty"`
	To          MessageAddress `json:"to,omitempty"`
}

MessageRequest represents a Message to be sent through Intercom from/to an Admin or Contact.

func NewContactMessage 

func NewContactMessage(from MessagePerson, body string) MessageRequest

NewContactMessage creates a new *Message from a Contact.

func NewEmailMessage 

func NewEmailMessage(template MessageTemplate, from, to MessagePerson, subject, body string) MessageRequest

NewEmailMessage creates a new *Message of email type.

func NewInAppMessage 

func NewInAppMessage(from, to MessagePerson, body string) MessageRequest

NewInAppMessage creates a new *Message of InApp (widget) type.

type MessageResponse 

type MessageResponse struct {
	MessageType string          `json:"message_type,omitempty"`
	ID          string          `json:"id"`
	CreatedAt   int64           `json:"created_at,omitempty"`
	Owner       MessageAddress  `json:"owner,omitempty"`
	Subject     string          `json:"subject,omitempty"`
	Body        string          `json:"body,omitempty"`
	Template    MessageTemplate `json:"template,omitempty"`
}

MessageResponse represents a Message response from Intercom.

func (MessageResponse) String 

func (m MessageResponse) String() string

type MessageService 

type MessageService struct {
	Repository MessageRepository
}

MessageService handles interactions with the API through an MessageRepository.

func (*MessageService) Save 

func (m *MessageService) Save(message *MessageRequest) (MessageResponse, error)

Save (send) a Message

type MessageTemplate 

type MessageTemplate int

MessageTemplate determines the template used for email messages to Contacts (plain or personal) 

const (
	NO_TEMPLATE MessageTemplate = iota
	PERSONAL_TEMPLATE
	PLAIN_TEMPLATE
)

func (MessageTemplate) String 

func (template MessageTemplate) String() string

func (*MessageTemplate) UnmarshalJSON 

func (template *MessageTemplate) UnmarshalJSON(b []byte) error

type Notification 

type Notification struct {
	ID               string        `json:"id,omitempty"`
	CreatedAt        int64         `json:"created_at,omitempty"`
	Topic            string        `json:"topic,omitempty"`
	DeliveryAttempts int64         `json:"delivery_attempts,omitempty"`
	FirstSentAt      int64         `json:"first_sent_at,omitempty"`
	RawData          *Data         `json:"data,omitempty"`
	Conversation     *Conversation `json:"-"`
	Contact          *Contact      `json:"-"`
	Tag              *Tag          `json:"-"`
	Company          *Company      `json:"-"`
	Event            *Event        `json:"-"`
}

Notification is the object delivered to a webhook.

func NewNotification 

func NewNotification(r io.Reader) (*Notification, error)

NewNotification parses a Notification from json read from an io.Reader. It may only contain partial objects (such as a single conversation part) depending on what is provided by the webhook.

type PageParams 

type PageParams struct {
	Page       int64 `json:"page" url:"page,omitempty"`
	PerPage    int64 `json:"per_page" url:"per_page,omitempty"`
	TotalPages int64 `json:"total_pages" url:"-"`
}

PageParams determine paging information to and from the API

type Plan 

type Plan struct {
	ID   string `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

The Plan a Company is on

func (Plan) String 

func (p Plan) String() string

type Reply 

type Reply struct {
	Type           string   `json:"type"`
	ReplyType      string   `json:"message_type"`
	Body           string   `json:"body,omitempty"`
	AssigneeID     string   `json:"assignee_id,omitempty"`
	AdminID        string   `json:"admin_id,omitempty"`
	IntercomID     string   `json:"intercom_user_id,omitempty"`
	Email          string   `json:"email,omitempty"`
	AttachmentURLs []string `json:"attachment_urls,omitempty"`
}

A Reply to an Intercom conversation

type ReplyType 

type ReplyType int

ReplyType determines the type of Reply 

const (
	CONVERSATION_COMMENT ReplyType = iota
	CONVERSATION_NOTE
	CONVERSATION_ASSIGN
	CONVERSATION_OPEN
	CONVERSATION_CLOSE
)

func (ReplyType) String 

func (reply ReplyType) String() string

type Segment 

type Segment struct {
	ID         string `json:"id,omitempty"`
	Name       string `json:"name,omitempty"`
	CreatedAt  int64  `json:"created_at,omitempty"`
	UpdatedAt  int64  `json:"updated_at,omitempty"`
	PersonType string `json:"person_type,omitempty"`
}

Segment represents an Segment in Intercom.

func (Segment) String 

func (s Segment) String() string

type SegmentAPI 

type SegmentAPI struct {
	// contains filtered or unexported fields
}

SegmentAPI implements SegmentRepository

type SegmentList 

type SegmentList struct {
	Segments []Segment `json:"segments,omitempty"`
}

SegmentList, an object holding a list of Segments

type SegmentRepository 

type SegmentRepository interface {
	// contains filtered or unexported methods
}

SegmentRepository defines the interface for working with Segments through the API.

type SegmentService 

type SegmentService struct {
	Repository SegmentRepository
}

SegmentService handles interactions with the API through a SegmentRepository.

func (*SegmentService) Find 

func (t *SegmentService) Find(id string) (Segment, error)

Find a particular Segment in the App

func (*SegmentService) List 

func (t *SegmentService) List() (SegmentList, error)

List all Segments for the App

type SocialProfile 

type SocialProfile struct {
	Name     string `json:"name,omitempty"`
	ID       string `json:"id,omitempty"`
	Username string `json:"username,omitempty"`
	URL      string `json:"url,omitempty"`
}

SocialProfile represents a social account for a Contact.

type SocialProfileList 

type SocialProfileList struct {
	SocialProfiles []SocialProfile `json:"social_profiles,omitempty"`
}

SocialProfileList is a list of SocialProfiles for a Contact.

type StartingAfterParam 

type StartingAfterParam struct {
	PerPage       int64  `json:"per_page,omitempty"`
	StartingAfter string `json:"starting_after,omitempty"`
}

StartingAfterParam holds the cursor for the next page.

func (*StartingAfterParam) UnmarshalJSON 

func (s *StartingAfterParam) UnmarshalJSON(data []byte) error

UnmarshalJSON handles both formats returned by the Intercom API:

type Tag 

type Tag struct {
	ID   string `json:"id,omitempty"`
	Name string `json:"name,omitempty"`
}

Tag represents an Tag in Intercom.

func (Tag) String 

func (t Tag) String() string

type TagAPI 

type TagAPI struct {
	// contains filtered or unexported fields
}

TagAPI implements TagRepository

type TagList 

type TagList struct {
	Tags []Tag `json:"tags,omitempty"`
}

TagList, an object holding a list of Tags

type TagRepository 

type TagRepository interface {
	// contains filtered or unexported methods
}

TagRepository defines the interface for working with Tags through the API.

type TagService 

type TagService struct {
	Repository TagRepository
}

TagService handles interactions with the API through a TagRepository.

func (*TagService) Delete 

func (t *TagService) Delete(id string) error

Delete a Tag

func (*TagService) List 

func (t *TagService) List() (TagList, error)

List all Tags for the App

func (*TagService) Save 

func (t *TagService) Save(tag *Tag) (Tag, error)

Save a new Tag for the App.

func (*TagService) Tag 

func (t *TagService) Tag(taggingList *TaggingList) (Tag, error)

Tag Users or Companies using a TaggingList.

type Tagging 

type Tagging struct {
	ID        string `json:"id,omitempty"`
	UserID    string `json:"user_id,omitempty"`
	Email     string `json:"email,omitempty"`
	CompanyID string `json:"company_id,omitempty"`
	Untag     *bool  `json:"untag,omitempty"`
}

A Tagging is an object identifying a User or Company to be tagged, that can optionally be set to untag.

type TaggingList 

type TaggingList struct {
	Name      string    `json:"name,omitempty"`
	Users     []Tagging `json:"users,omitempty"`
	Companies []Tagging `json:"companies,omitempty"`
}

TaggingList is an object used to Tag Users and Companies. The Name should be that of the Tag required, and Users and Companies are lists of Taggings

type UserCompany 

type UserCompany = ContactCompany

UserCompany is an alias for ContactCompany for backwards compatibility.

Source Files

View all Source files

Directories

Path Synopsis
cmd
articles command
contacts command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.