How customer service work in ServiceNow (cases, incidents, problems, install base and entitlements) can reach HubSpot, so sales, account managers and marketing see each account's service health next to its pipeline and renewals, and how a won deal in HubSpot can start onboarding in ServiceNow.
Many enterprises run customer service in ServiceNow and run marketing, sales and renewals in HubSpot. The service team works the case. The people who renew and expand the account need to know how service is going before they call.
Public documentation. The client's own admin issues credentials, with no vendor approval needed.
Open API. Self-serve for the client's admin: the REST APIs are documented publicly, and a dedicated integration user holds only the roles it needs.
Based on the vendor's public documentation. Access terms are confirmed with the vendor and the client in discovery.
Every ServiceNow table is reachable through a documented REST API, so HubSpot can show the service health of every account and hand new customers to the service team the moment a deal closes.
Campaign Creators assessment
CC builds this directly on ServiceNow's REST APIs. The Table API reads and writes any table the integration user is allowed to see, including the Customer Service Management (CSM) tables for accounts, contacts and cases. Business rules call a CC-hosted endpoint through outbound REST messages when records change. The Import Set API and a Scripted REST endpoint receive data from HubSpot, so ServiceNow's own transform rules decide how it lands. Two things set the pace: the client's ServiceNow admin grants roles and rate limits for the integration user, and the client decides which system owns the account record.
Ratings are CC judgments from ServiceNow's public API documentation. Table names, fields, roles and rate-limit rules are confirmed against the client's instance during discovery, because every instance is configured differently.
The Table API reads and writes any table by name, with encoded queries, field lists and paging. Cases, incidents, problems, install base and entitlements all use the same pattern.
Custom fields (u_ prefix), custom case states, access controls and rate-limit rules vary by instance. CC inventories the client's instance before the field list is signed.
ServiceNow CSM accounts and HubSpot companies describe the same customers. The client decides which system creates accounts and which fields each side may change before any build starts.
Seven parts of ServiceNow matter to HubSpot. Four carry the core sync, two add service context, and one carries HubSpot data back into ServiceNow.
Create, read, update and delete records on any ServiceNow table, filtered with encoded queries.
The customers the service team supports: business accounts, their contacts, and individual consumers where the client serves them.
Customer service cases with state, priority, account, contact, product and assignment. They become HubSpot tickets in a ServiceNow pipeline.
For clients that also run IT service management, incidents and problems that affect a customer account roll up to the HubSpot company as health signals.
What each customer owns (install base items and sold products) and what support they are entitled to, including entitlement end dates.
Business rules run when a record is inserted or updated, and an outbound REST message notifies a CC-hosted endpoint, so changes reach HubSpot as they happen.
Data from HubSpot lands in a staging table, and transform maps write it to the target table. A Scripted REST endpoint can take a won deal and open onboarding in one call.
ServiceNow business rules notify a CC-hosted endpoint when cases and accounts change. The integration layer fetches the full record through the Table API, matches the account and contact to HubSpot, computes service-health rollups and writes in batches. HubSpot sends won deals and account context back through the Import Set API or a Scripted REST endpoint.
Agents work cases and incidents in ServiceNow. HubSpot holds a read-only copy for context and reporting and never changes a case state.
Companies, contacts, owners and deals live in HubSpot. ServiceNow receives the account context its agents need and a clean handoff when a deal closes.
HubSpot stores counts, dates, states and flags. Work notes, comments and attachments stay in ServiceNow, linked by case number.
Each phase ends on a gate the client signs off before the next begins. ServiceNow → HubSpot goes live first, then the onboarding handoff from HubSpot.
List the CSM and ITSM tables in use, custom fields and case states, the account model (business accounts, consumers or both), and the instances (development, test, production).
The client's ServiceNow admin creates a dedicated integration user with read roles on the agreed tables, write access to the staging tables, an OAuth client, and a rate-limit rule sized for the sync.
Agree which system creates accounts and contacts, which fields each side may change, and the match rules (sys_id once linked; email for contacts; domain for accounts).
Create the ServiceNow ticket pipeline, the Installed Products custom object, custom properties, association labels and property groups in a HubSpot sandbox.
Build the business rules and outbound REST messages with the client's admin, the CC endpoint, record fetcher, health rollups, ticket and install base sync, and the onboarding handoff through the Import Set API or Scripted REST.
Load accounts, contacts and an agreed case history window in pages, paced under the rate limit, then compute rollups once so company views start complete.
Build renewal-risk alerts, onboarding notifications and service views with notifications paused, run two weeks in parallel, then switch on in production.
Table names follow ServiceNow's documentation. Field names shown are standard ServiceNow fields; each instance can add custom fields (u_ prefix) and change choice values, so every row is confirmed against the client's instance in discovery.
| ServiceNow field | HubSpot property | Object | Direction | Notes |
|---|---|---|---|---|
| Accounts & contacts · CSM | ||||
| customer_account.sys_id | sn_account_sys_id | Company | SN → HS | Match key once linked. Unique. |
| customer_account.number | sn_account_number | Company | SN → HS | Human-readable account number. |
| customer_account.name | name | Company | ↔ Both | Owner agreed in discovery. HubSpot creates prospects; ServiceNow receives them at onboarding. |
| customer_account website | domain | Company | ↔ Both | Primary match key before linking. Confirm field use in discovery. |
| customer_account.parent | Parent company association | Company | SN → HS | Keeps the account hierarchy. |
| customer_contact.sys_id | sn_contact_sys_id | Contact | SN → HS | Match key once linked. |
| customer_contact.email | Contact | ↔ Both | Match key. Support-only contacts can be set as non-marketing. | |
| first_name, last_name, phone | firstname, lastname, phone | Contact | ↔ Both | Fill blanks only in each direction. |
| customer_contact.account | Contact to company association | Contact | SN → HS | |
| Cases · sn_customerservice_case | ||||
| number | sn_case_number | Ticket | SN → HS | Match key. Unique. |
| short_description | subject | Ticket | SN → HS | |
| state | hs_pipeline_stage | Ticket | SN → HS | ServiceNow case pipeline. Choice values confirmed per instance. |
| priority | hs_ticket_priority | Ticket | SN → HS | Mapped to Low, Medium, High, Urgent. |
| account, contact | Ticket associations | Ticket | SN → HS | Associated to the HubSpot company and contact. |
| assigned_to | hubspot_owner_id | Ticket | SN → HS | Matched on agent email. Unmatched agents leave owner blank. |
| assignment_group | sn_assignment_group | Ticket | SN → HS | Group name from the reference field. |
| product | sn_product | Ticket | SN → HS | Display value of the product reference. |
| opened_at, resolved_at, closed_at | createdate, sn_resolved_at, closed_date | Ticket | SN → HS | |
| Incidents, problems & install base | ||||
| incident (open, by account) | sn_open_incidents | Company | SN → HS | Computed in the integration layer. Account field confirmed per instance. |
| incident (priority 1, last 90 days) | sn_p1_incidents_90d | Company | SN → HS | Computed in the integration layer. |
| problem (open, linked to account) | sn_open_problems | Company | SN → HS | Only where problems link to customer accounts. |
| sn_install_base_item | Installed Product (custom object) | Custom object | SN → HS | Product, serial or name, status, install date. Associated to the company. |
| service_entitlement end date | sn_entitlement_end | Company | SN → HS | Earliest active entitlement end. Renewal signal. |
| Revenue context & onboarding | ||||
| Deal closed won | Onboarding case or catalog request | Deal | HS → SN | Sent through the Import Set API or a Scripted REST endpoint. Target table agreed in discovery. |
| Deal line items | Onboarding request details | Line item | HS → SN | Listed on the onboarding record so the service team sees what was sold. |
| Company owner, tier, renewal date | customer_account custom fields (u_) | Company | HS → SN | Agents see the account's commercial context. |
| Onboarding case state | sn_onboarding_status | Deal | SN → HS | Shows sales and success where onboarding stands. |
| Open cases, P1 incidents, entitlements | sn_service_health | Company | SN → HS | Green, amber or red, from rules the client signs off. |
ServiceNow access is granted by the client's instance admin. Values below come from ServiceNow's public API documentation; instance-specific settings are confirmed in discovery.
| Topic | ServiceNow | HubSpot |
|---|---|---|
| Access model | Self-serve for the client's admin. A dedicated integration user holds only the roles the sync needs; access controls on each table decide what the API returns. | Private app access token or OAuth 2.0 public app, scoped per object. |
| Interfaces | REST over HTTPS at the client's instance URL: Table API (/api/now/table/), Import Set API (/api/now/import/), and Scripted REST APIs the client hosts. JSON or XML. | REST APIs: CRM objects, tickets, custom objects, associations, properties. |
| Authentication | OAuth 2.0 (authorization code, client credentials or JWT bearer) through an OAuth application registered in the instance, or basic auth for the integration user. CC recommends OAuth. | Bearer token on every call. |
| Rate limits | Set by the instance admin as inbound REST rate-limit rules, per user, role or all users, per hour. Exceeded calls return 429 with a Retry-After header. No default is published; confirm the rule for the integration user. | Per-10-second burst and daily limits by subscription tier. |
| Paging & volume | Table API pages with sysparm_limit and sysparm_offset; the Link and X-Total-Count headers support paging and reconciliation. The Table API inserts one record per call; insertMultiple on the Import Set API handles batches. | Batch endpoints handle volume. |
| Change detection | Async business rules call a CC endpoint through outbound REST messages on insert and update. A scheduled Table API query on sys_updated_on catches anything a rule misses. | HubSpot workflows trigger the outbound handoff and account context. |
| Instances & environments | Each client has its own instance URL, usually with development and test instances. Instance clones copy production data and settings, so endpoints and credentials are re-pointed after each clone. | HubSpot sandbox for build and testing; production portal at launch. |
Severity reflects impact on the SOW, not technical difficulty alone.
ServiceNow accounts and HubSpot companies overlap. Without a signed rule for who creates and edits accounts, duplicates follow. The rule is agreed before the build.
ServiceNow does not publish a default. The client's admin creates a rule for the integration user sized for the backfill and the live sync, and the layer backs off on 429 responses.
The API returns only what the integration user's roles allow, and sysparm_limit applies before access checks. Roles are tested against known records before backfill.
Cloning production into a test instance copies business rules that call the CC endpoint. Clone settings exclude or re-point them so test data never reaches the production portal.
Large service desks create many cases. HubSpot stores open cases and an agreed history window; older cases stay in ServiceNow and count toward rollups only.
Each instance has its own u_ fields and case states. The inventory is signed in discovery, and new values are flagged before they sync.
Open escalations, priority 1 incidents and expiring entitlements attach to the renewal deal and alert the account owner before the renewal conversation.
A won deal opens onboarding in ServiceNow with the account, contacts and what was sold, so the service team starts with full context.
Open cases, recent incidents and service health sit on the company record, so no one pitches into an unresolved problem.
Installed products and entitlement dates become HubSpot lists for upgrade, add-on and renewal campaigns.
Contacts at accounts with open priority 1 incidents can be held out of promotional sends until service recovers.
Service health, pipeline and product usage meet in HubSpot dashboards for leaders and customer success.
The integration follows one customer from the signed deal through service to the renewal conversation, with ServiceNow running the service work and HubSpot running the relationship.
All custom properties use the sn_ prefix in a ServiceNow property group. Standard HubSpot ticket properties are used wherever one fits. Rollups are calculated in the integration layer so every report agrees.
| Internal name | Label | Object | Type | Source / logic |
|---|---|---|---|---|
| sn_account_sys_id | ServiceNow Account ID | Company | Single-line text | customer_account sys_id; unique |
| sn_account_number | ServiceNow Account Number | Company | Single-line text | customer_account number |
| sn_contact_sys_id | ServiceNow Contact ID | Contact | Single-line text | customer_contact sys_id; unique |
| sn_case_number | ServiceNow Case Number | Ticket | Single-line text | Case number; unique |
| sn_assignment_group | Assignment Group | Ticket | Dropdown | Case assignment group |
| sn_product | ServiceNow Product | Ticket | Dropdown | Case product display value |
| sn_open_cases | Open ServiceNow Cases | Company | Number | Count of cases not resolved, closed or cancelled |
| sn_open_incidents | Open Incidents | Company | Number | Count of open incidents for the account |
| sn_p1_incidents_90d | P1 Incidents (90 days) | Company | Number | Priority 1 incidents in 90 days |
| sn_entitlement_end | Entitlement End Date | Company | Date picker | Earliest active entitlement end |
| sn_service_health | Service Health | Company | Dropdown | Green, amber or red from signed rules |
| sn_onboarding_status | Onboarding Status | Deal | Dropdown | State of the onboarding case |
Choose the tables and fields for this engagement and the direction each one syncs. Required fields are the keys the integration cannot run without. Copy the summary into the SOW or a reply to the client.
Based on public documentation. Items marked for confirmation are checked against the client's ServiceNow instance during discovery.
Yes, through a custom build on ServiceNow's REST APIs. The Table API reads and writes the Customer Service Management tables for accounts, contacts and cases, business rules notify a CC-hosted endpoint when records change, and the Import Set API or a Scripted REST endpoint receives data from HubSpot.
ServiceNow accounts and contacts match to HubSpot companies and contacts, and cases become read-only tickets in a ServiceNow pipeline. Incidents, problems, install base items and entitlement end dates roll up to the company as service-health and renewal signals. Won HubSpot deals go back to ServiceNow to start onboarding.
ServiceNow owns the service work: agents work cases and incidents there, and HubSpot never changes a case state. HubSpot owns the revenue relationship, including pipeline, renewals and marketing. The client decides which system creates accounts and which fields each side may change before the build starts.
Seven phases, each closed by a client sign-off: discovery and an instance inventory, access and a dedicated integration user, ownership and identity rules, the HubSpot data model, the build, a backfill, and a parallel run before workflows are switched on.
Timeline and cost depend on the ServiceNow tables and custom fields in scope, how the client's instance is configured, the history to load, and whether onboarding write-back is included. Campaign Creators confirms these in discovery and provides a fixed scope before the build starts.