Ellipse Gradient for Header
ServiceNow logo

Integrate ServiceNow with Martini

ServiceNow integration options at a glance

Martini integrates ServiceNow with enterprise systems by consuming its REST APIs, SOAP web services, Table API, Import Set API, Attachment API, and application-specific endpoints. Martini can also expose REST services for ServiceNow outbound REST messages, Flow Designer actions, business rules, or configured webhook-style callbacks. Workflows transform ServiceNow JSON, XML, attachment, and imported data into formats for applications, databases, queues, files, and downstream APIs. Scheduled workflows support incremental synchronization using fields such as sys_updated_on, while mappings, business rules, retries, pagination, and idempotency controls help maintain reliable integrations across incidents, changes, CMDB data, users, and service requests.

Integration pointSupported by ServiceNow?Common use casesHow Martini supports it
REST APIYesServiceNow supports the Table API, Import Set API, Attachment API, Aggregate API, Scripted REST APIs, and application-specific REST APIs. Common uses include synchronizing Incidents, Change Requests, Configuration Items, Users, and Service Catalog Requests.Martini can consume ServiceNow REST endpoints directly, using generated or configured services, mappings, pagination, query parameters, and workflow logic. Martini can also expose REST endpoints that ServiceNow calls through outbound REST messages or related mechanisms.
SOAP APIYesServiceNow supports SOAP web services for integrations where a WSDL and the required instance configuration are available. SOAP can be used for legacy or contract-driven operations alongside REST APIs.Martini can consume ServiceNow SOAP web services when the WSDL and authentication details are provided. SOAP responses can be transformed and routed to applications, databases, files, queues, or other APIs.
WebhooksLimitedServiceNow can send webhook-style HTTP callbacks through business rules, Flow Designer, IntegrationHub, outbound REST messages, or custom application logic. Coverage is selected and configuration-dependent rather than a universal notification stream for every table and event.Martini can expose REST services and receive configured ServiceNow callbacks. Workflows can validate payloads, authenticate requests, deduplicate deliveries, transform fields, and return acknowledgments.
Events / triggersLimitedServiceNow events and notifications can drive selected outbound actions, but event coverage and delivery behavior depend on instance configuration and the application involved. Scheduled polling using sys_updated_on may be more appropriate for broad synchronization.Martini supports scheduled triggers and incoming HTTP-triggered workflows. It can combine callbacks with polling, apply routing rules, and retain synchronization watermarks for reliable processing.
Bulk API / batch exportYes, for selected APIsThe Import Set API and applicable REST batch operations support larger loads and transformation workflows. ServiceNow also supports selected bulk export and file-exchange scenarios depending on instance configuration.Martini can call Import Set or supported batch endpoints, process paginated responses, and transform exported payloads. Large loads can be controlled with batching, concurrency limits, retry policies, and reconciliation logic.
Database accessNoThe research notes do not confirm direct database access to ServiceNow. ServiceNow data should be accessed through its supported REST, SOAP, Import Set, attachment, or configured outbound integration mechanisms.Martini can write synchronized ServiceNow data to external databases through supported database connectivity, but it should not connect directly to the ServiceNow platform database. API-based access preserves ServiceNow security and business-rule behavior.
File import/exportLimitedServiceNow supports attachments and selected export or file-exchange features. The Attachment API handles files separately from ordinary table fields, with association through a target table and sys_id.Martini can process ServiceNow attachment or exported file payloads and route them to files, databases, applications, or APIs. Workflows should account for MIME types, file sizes, binary or multipart handling, and parent-record association.
AuthenticationYesServiceNow commonly supports OAuth 2.0, Basic Authentication, and mutual TLS for selected secured scenarios. API keys and tokens may be available for specific APIs or configurations, with access constrained by users, groups, roles, ACLs, scopes, and policies.Martini can use configured authentication and protected secrets when consuming ServiceNow APIs or exposing services for ServiceNow. Credentials should remain in protected configuration, while ServiceNow administrators provision the application registry, integration user, roles, ACLs, and scopes.

How ServiceNow exposes data and business events

ServiceNow REST APIs

ServiceNow fully supports HTTP REST APIs, including the Table API, Import Set API, Attachment API, Aggregate API, Scripted REST APIs, and application-specific endpoints. These APIs provide the primary integration path for table operations, incremental synchronization, imports, aggregations, and attachments.

How This works in Martini

How this works in Martini: Martini consumes the selected ServiceNow endpoint, supplies configured authentication and query parameters, handles pagination and response validation, maps the returned JSON or binary data, and invokes downstream services or writes to target systems.

Example Martini workflow

Scheduled trigger
Call REST API
Handle pagination
Map fields
Write target

ServiceNow SOAP web services

ServiceNow supports SOAP web services for integrations that require a WSDL-based contract or legacy SOAP operation. Availability and behavior depend on the ServiceNow instance and the WSDL and authentication configuration supplied by the administrator.

How This works in Martini

How this works in Martini: Martini consumes the WSDL-backed SOAP service, sends the required request structure, transforms XML responses into the target model, and applies workflow routing and error handling.

Example Martini workflow

Receive trigger
Call SOAP service
Transform XML
Apply rules
Handle errors

ServiceNow webhook-style callbacks

ServiceNow can invoke external HTTP services through business rules, Flow Designer, IntegrationHub, outbound REST messages, events, notifications, or custom application logic. Delivery is selected and configuration-dependent, not a universal webhook stream for all record changes.

How This works in Martini

How this works in Martini: Martini exposes a REST endpoint for the configured callback, authenticates and validates the request, deduplicates using a correlation key or sys_id, transforms the payload, and acknowledges the request before or after downstream processing according to the workflow design.

Example Martini workflow

Receive callback
Validate request
Deduplicate event
Map payload
Acknowledge request

ServiceNow incremental synchronization

ServiceNow supports query-based incremental synchronization using sys_updated_on or another suitable modification field. This approach is useful when callback coverage is incomplete or when a controlled reconciliation process is required.

How This works in Martini

How this works in Martini: A scheduler calls a filtered ServiceNow endpoint, retains a successful watermark, uses an overlap window when appropriate, processes pages idempotently, and advances the watermark only after successful handling.

Example Martini workflow

Schedule workflow
Read watermark
Query changed data
Process pages
Save watermark

ServiceNow imports and attachments

The Import Set API supports loading external data into import sets and applying transform maps before it reaches target tables. The Attachment API supports uploading, downloading, and associating files with ServiceNow records.

How This works in Martini

How this works in Martini: Martini sends mapped batches or attachment payloads to the appropriate ServiceNow API, preserves parent table and sys_id associations, and routes failures for retry without duplicating the parent operation.

Example Martini workflow

Prepare batch
Map payload
Upload data
Associate attachment
Retry failures

Common ServiceNow integration patterns

Pattern 1: Synchronize incidents with IT operations

When to use this pattern

Use this pattern when ServiceNow remains the incident system of record but monitoring, ticketing, customer-support, or analytics systems need current incident data. Scheduled polling is suitable for broad coverage, while selected callbacks can reduce latency.

Data Flow
ServiceNow
Martini
IT operations platform
Example Mapping
ServiceNow FieldCanonical FieldTarget Field
numberincidentReferenceticketNumber
short_descriptionsummarytitle
priorityseveritypriority
sys_updated_onlastModifiedAtupdatedAt
Martini Implementation

A Martini scheduler queries the incident table with a sys_updated_on watermark, explicit field selection, encoded filters, and pagination. It maps and enriches each Incident, uses sys_id as the stable external reference, applies status and priority rules, and writes an idempotent update to the target platform. The workflow stores the watermark only after successful processing and routes transient failures for backoff and retry.

Martini features used:
  • REST API consumption
  • scheduler trigger
  • data mapper
  • pagination
  • idempotency controls
  • error handling and retry

Pattern 2: Enrich Configuration Items from infrastructure systems

When to use this pattern

Use this pattern when ServiceNow CMDB data must be reconciled with asset, cloud, network, or application inventories. It is appropriate when stable identifiers are available and duplicate CI creation must be prevented.

Data Flow
Infrastructure system
Martini
ServiceNow CMDB
Example Mapping
ServiceNow FieldCanonical FieldTarget Field
resourceIdexternalResourceIdcorrelation_id
nameconfigurationItemNamename
serialNumberserialNumberserial_number
environmentlifecycleEnvironmentenvironment
Martini Implementation

Martini retrieves source metadata, queries cmdb_ci or the appropriate child CI table, and reconciles records using serial numbers, resource IDs, names, or approved custom correlation fields. Business rules determine whether to update an existing Configuration Item or stage data through the Import Set API. Conflicts and unmatched identifiers are held for review rather than creating uncontrolled duplicates.

Martini features used:
  • API consumption
  • data mapper
  • record reconciliation
  • Import Set API
  • conditional routing
  • error queue and replay

Pattern 3: Orchestrate Service Catalog requests

When to use this pattern

Use this pattern when ServiceNow should remain the system of record for a catalog request while Martini coordinates provisioning, approval, fulfillment, or external application workflows.

Data Flow
ServiceNow
Martini
Provisioning and approval systems
Example Mapping
ServiceNow FieldCanonical FieldTarget Field
request.numberrequestReferenceexternalRequestId
sc_req_item.cat_itemrequestedServiceserviceCode
requested_forrequesterIduserId
quantityrequestedQuantityquantity
Martini Implementation

ServiceNow invokes a Martini REST service for a selected request or request item. Martini authenticates the call, validates mandatory fields and allowed catalog items, routes the request to downstream systems, and returns an acknowledgment with a correlation identifier. Completion or failure updates are sent back to sc_request or sc_req_item, while duplicate callbacks and downstream retries are controlled by the correlation key.

Martini features used:
  • REST API exposure
  • webhook-style callback handling
  • validation
  • business rules
  • orchestration
  • correlation and retry handling

Pattern 4: Synchronize change-management outcomes

When to use this pattern

Use this pattern when approved or scheduled Change Requests must be shared with deployment, infrastructure, or compliance systems and implementation results must return to ServiceNow.

Data Flow
ServiceNow
Martini
Deployment and compliance systems
ServiceNow
Example Mapping
ServiceNow FieldCanonical FieldTarget Field
numberchangeReferencechangeId
riskchangeRiskriskLevel
planned_start_dateplannedStartAtscheduledStart
implementation_statusimplementationResultdeploymentStatus
Martini Implementation

Martini retrieves change_request records filtered for approved or scheduled states, maps change details, and sends them to deployment or compliance services. Results such as deployment identifiers and validation outcomes are transformed back into ServiceNow updates. Selected state transitions can use configured ServiceNow callbacks; otherwise, scheduled polling provides a controlled alternative. Updates use sys_id and state checks to prevent repeated side effects.

Martini features used:
  • scheduled workflows
  • REST API consumption
  • REST API exposure
  • state-based routing
  • data mapping
  • idempotent updates

How to build a ServiceNow integration in Martini

Objective

Establish the ServiceNow API relationship and ensure the instance is configured for the selected integration method.

Instructions in Martini

  • Choose REST or SOAP endpoints, or define the Martini REST endpoint ServiceNow will call.
  • Configure OAuth 2.0, Basic Authentication, mutual TLS, or another confirmed method.
  • Store credentials, tokens, and certificates as protected configuration or secrets.
  • Ask the ServiceNow administrator to provision the integration user, roles, ACLs, scopes, and API policies.

Objective

Select a trigger that matches the required latency, coverage, and ServiceNow configuration.

Instructions in Martini

  • Use a scheduler for incremental queries based on sys_updated_on or an approved modification field.
  • Use a Martini REST endpoint for configured ServiceNow outbound callbacks.
  • Use polling when webhook-style event coverage is incomplete or configuration-dependent.
  • Define the synchronization watermark and overlap strategy before processing data.

Objective

Convert ServiceNow table, SOAP, attachment, or import payloads into a canonical model for downstream systems.

Instructions in Martini

  • Select the required table, fields, references, and API parameters.
  • Map identifiers such as sys_id separately from display values.
  • Transform JSON, XML, binary, or imported data into the target structure.
  • Handle reference fields explicitly and preserve both ServiceNow and external identifiers.

Objective

Implement validation, routing, reconciliation, and side-effect controls before writing data.

Instructions in Martini

  • Validate mandatory fields, ACL-dependent fields, statuses, and supported catalog items.
  • Route Incidents, Change Requests, Configuration Items, or Service Catalog Requests by state, priority, ownership, or correlation fields.
  • Use deterministic keys and duplicate checks before creating or updating data.
  • Account for ServiceNow business rules, notifications, approvals, flows, audit entries, and SLA logic.

Objective

Send transformed data to the target application, database, queue, file, or ServiceNow API while preserving traceability.

Instructions in Martini

  • Call the target service or write through Martini-supported database, file, or messaging operations.
  • Use the ServiceNow Table API, Scripted REST API, Import Set API, or Attachment API as appropriate.
  • Persist correlation identifiers and the last successful watermark.
  • Use controlled concurrency and batch operations for larger data loads.

Objective

Operate the integration safely under rate limits, transient failures, schema changes, and duplicate delivery.

Instructions in Martini

  • Classify 429 and transient 5xx responses for exponential backoff and retry.
  • Do not blindly retry validation, authentication, or authorization failures.
  • Log correlation identifiers, table names, sys_id values, request outcomes, and watermark progress.
  • Test in a non-production ServiceNow instance and route unrecoverable messages for review and replay.

Common ServiceNow data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Incidents (incident)Synchronize service interruptions, assignment, priority, impact, urgency, state, and resolution information.IT operations platforms, monitoring tools, customer-support systems, data warehousesMartini queries the Table API, commonly incrementally with sys_updated_on, maps fields using sys_id as the stable reference, and applies idempotent updates with pagination and retry handling.
Change Requests (change_request)Coordinate planned changes, approvals, risk, scheduling, implementation, and closure.Deployment platforms, infrastructure tools, compliance systems, reporting databasesMartini retrieves approved or scheduled changes, applies routing and transformation rules, and writes implementation or validation outcomes back through the Table API or a Scripted REST API.
Problems (problem)Track underlying causes of incidents, investigation activity, and remediation work.ITSM reporting stores, analytics platforms, knowledge or remediation systemsMartini can synchronize Problem fields with downstream systems, preserve ServiceNow identifiers, and route updates according to state, ownership, or remediation rules.
Configuration Items (cmdb_ci and child CI tables)Represent infrastructure, applications, services, assets, and other configuration items in the CMDB.Asset systems, cloud platforms, network tools, application inventories, data warehousesMartini enriches CI data from external APIs, reconciles using serial numbers, resource IDs, names, or correlation fields, and updates ServiceNow or stages data through the Import Set API.
Users (sys_user)Synchronize identity, contact, department, manager, and account-status information.Identity platforms, HR systems, directories, support applicationsMartini maps reference and status fields carefully, uses stable identifiers, and applies least-privilege access and duplicate-prevention rules when writing updates.
Service Catalog Requests (sc_request and sc_req_item)Orchestrate requests submitted through the Service Catalog and the individual items associated with them.Provisioning systems, approval platforms, asset systems, fulfillment applicationsMartini can receive an outbound request, validate and route it, invoke downstream services, return a correlation identifier, and post status updates to the request tables.

Authentication and security considerations

Use governed credentials

ServiceNow supports OAuth 2.0, Basic Authentication, and mutual TLS for selected secured scenarios. API keys and tokens may be available for specific APIs or instance configurations.

  • Store client credentials, tokens, and certificates in Martini protected configuration or secrets.
  • Prefer a dedicated ServiceNow integration user with least-privilege roles and permissions.
  • Coordinate OAuth application registration, scopes, token renewal, and certificate rotation with ServiceNow administrators.

Validate authorization

ServiceNow access is governed by users, groups, roles, ACLs, application scopes, field permissions, and API policies. A valid credential can still receive a 403 response when table or field access is missing.

  • Test both table-level and field-level access.
  • Restrict exposed Martini endpoints and validate incoming ServiceNow requests.
  • Review audit, notification, workflow, and business-rule side effects before production deployment.

Operational considerations for ServiceNow integrations

Control API usage

Design for instance capacity, request limits, pagination, and transient failures. Use explicit field selection, encoded queries, bounded page sizes, controlled concurrency, and Import Set or supported batch mechanisms for larger loads.

  • Retry rate-limit and selected 5xx responses with exponential backoff.
  • Do not blindly retry validation or authorization failures.
  • Use sys_updated_on watermarks with an overlap window where appropriate.

Protect synchronization quality

Use sys_id and external identifiers for correlation and idempotency. Webhook-style callbacks may be duplicated, while ServiceNow business rules, notifications, approvals, flows, and data policies can create side effects.

  • Prevent duplicate Incidents, Change Requests, Configuration Items, and Service Catalog Requests.
  • Handle reference values explicitly rather than assuming display names are unique.
  • Test custom tables, fields, plugins, scoped applications, and API behavior in a non-production instance.
  • Monitor schema changes, attachment limits, MIME types, and binary or multipart handling.

Why use Martini instead of scripts or point-to-point integrations?

Centralize integration behavior

Scripts and point-to-point links often duplicate authentication, mapping, retry, pagination, and monitoring logic. Martini provides a maintainable integration runtime for consuming ServiceNow APIs, exposing usable services, and coordinating workflows across enterprise systems.

  • Reuse services and mappings across Incident, Change Request, CMDB, User, and Service Catalog workflows.
  • Separate credentials and environment configuration from workflow logic.
  • Combine scheduled polling with configured callbacks when ServiceNow event coverage is limited.
  • Apply consistent transformation, validation, idempotency, error handling, and operational monitoring.

Support evolution

Martini allows teams to adapt mappings and business rules as ServiceNow tables, fields, applications, and integrations change, while retaining the flexibility to add custom logic when standard transformations are insufficient.

Frequently asked questions

Can Martini integrate ServiceNow?

Yes. Martini can integrate ServiceNow by consuming its REST APIs and SOAP web services, exposing REST services for ServiceNow outbound calls, and receiving webhook-style callbacks when those callbacks are configured in the ServiceNow instance. Martini can transform ServiceNow data and route it to applications, databases, files, queues, and other APIs.

Which ServiceNow APIs can Martini consume?

Martini can consume ServiceNow REST endpoints such as the Table API, Import Set API, Attachment API, Aggregate API, Scripted REST APIs, and application-specific REST APIs. It can also consume SOAP web services when the required WSDL and authentication configuration are available.

Can Martini receive ServiceNow webhooks or events?

Yes, when ServiceNow is configured to send them. ServiceNow can invoke Martini through outbound REST messages, business rules, Flow Designer, IntegrationHub, events, notifications, or custom application logic, but coverage is selected and configuration-dependent rather than universal for every table and event.

How can ServiceNow changes be synchronized incrementally?

Use a scheduled Martini workflow to query the relevant table with sys_updated_on or another approved modification field. Store a successful watermark, consider an overlap window for timestamp precision and clock differences, paginate results, and use sys_id-based idempotency controls.

Can Martini synchronize ServiceNow data with a database?

Martini can consume ServiceNow APIs and write the resulting data to an external database through supported database connectivity. The research does not confirm direct access to the ServiceNow platform database, so integrations should use ServiceNow APIs rather than database connections.

How does Martini transform ServiceNow reference fields and attachments?

Martini can map JSON, XML, imported data, and attachment payloads into canonical or target formats. Reference fields may expose display values, links, or identifiers depending on API parameters, so workflows should explicitly choose the required value; attachments should be processed separately through the Attachment API and associated using the target table and sys_id.

Can Martini expose an API façade for ServiceNow?

Yes. Martini can expose REST services that provide a stable contract for downstream consumers or for ServiceNow to invoke. A façade can validate requests, hide ServiceNow-specific details, apply business rules, route to the Table API or Scripted REST API, and normalize responses.

What is the purpose of this ServiceNow integration page?

This page is an integration briefing for designing ServiceNow workflows with Martini. It outlines supported integration mechanisms, authentication considerations, common ServiceNow objects, practical synchronization patterns, transformation concerns, and operational controls without assuming a native ServiceNow connector.

Related Martini documentation

APIs

Workflows

Security

Operations

Deployment

Connect ServiceNow to your enterprise systems

Use Martini to design, deploy, and operate reliable ServiceNow integrations across APIs, workflows, databases, files, queues, and business applications.

EXPLORE MARTINI
BOOK A DEMO