.png)
ServiceNow App Engine Integration Guide
ServiceNow App Engine integrates with enterprise systems through ServiceNow REST and SOAP APIs, configured outbound callbacks, Import Sets, attachments, and platform security controls.
ServiceNow App Engine integration options at a glance
ServiceNow App Engine integrations generally use ServiceNow platform APIs and application-specific tables rather than a separate App Engine API. REST is the primary option for Table, Import Set, Attachment, Aggregate, Batch, scripted REST, and custom application APIs. SOAP remains available for legacy systems and WSDL-based contracts. Selected flows, business rules, events, and outbound REST messages can call Martini endpoints, although callback coverage must be configured for each relevant process. Import Sets, transform maps, scheduled processing, and batch patterns support larger loads. Martini can authenticate securely, orchestrate workflows, map custom and standard tables, manage attachments, and handle pagination, retries, validation, and deduplication.
| Integration point | Supported by ServiceNow App Engine? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | The Table, Import Set, Attachment, Aggregate, Batch, scripted REST, and application-facing REST APIs support record synchronization, custom application access, imports, queries, and file operations. | Martini can consume ServiceNow REST APIs from workflows, handle authentication and pagination, map payloads, apply business rules, and expose REST endpoints for ServiceNow calls. |
| SOAP APIs | Yes | Table-oriented SOAP services, scripted SOAP services, and SOAP-based outbound messages support legacy integrations and WSDL-based enterprise contracts. | Martini can consume ServiceNow SOAP services, transform XML messages, and route SOAP faults through workflow error handling. |
| Webhooks / outbound callbacks | Limited | Outbound REST messages, flows, events, business rules, and workflow activities can call external endpoints for selected tables, events, or application processes. | Martini can expose a REST endpoint and receive webhook-style HTTP requests, then validate, deduplicate, transform, and route selected callbacks. |
| Bulk / async / batch APIs | Yes | Import Sets, transform maps, scheduled imports, asynchronous processing, and REST Batch API patterns support staged or high-volume loading. | Martini can submit batches or Import Set payloads, track results, separate invalid rows, and retry transient failures without treating every row as an individual synchronous call. |
| File / attachment APIs | Yes | The Attachment API uploads, downloads, and manages files associated with ServiceNow records, subject to parent-record and attachment permissions. | Martini can transfer binary content and metadata, map parent identifiers, validate content types, and prevent repeated uploads with source identifiers or checksums. |
| Authentication | Yes | ServiceNow supports OAuth 2.0, Basic Authentication, authentication profiles, mutual TLS for applicable scenarios, roles, ACLs, application scopes, and OAuth scopes. | Martini stores environment-specific credentials as secrets and can orchestrate OAuth token acquisition and refresh in REST- or SOAP-consuming workflows. |
| Database / analytics access | Limited | ServiceNow provides supported reporting and analytics interfaces, but direct SQL access to the underlying platform database is not the normal integration model. | Martini should consume supported APIs, exports, reporting, or analytics interfaces rather than attempting direct database access. |
How ServiceNow App Engine exposes data and business events
ServiceNow REST APIs
ServiceNow provides REST APIs for platform and App Engine data, including the Table, Import Set, Attachment, Aggregate, Batch, scripted REST, and custom application-facing APIs. Access depends on table permissions, application scope, ACLs, and the integration user.
Martini implementation pattern
Martini implementation pattern: a workflow calls the appropriate ServiceNow REST endpoint, manages authentication and pagination, validates the response, maps reference and choice fields to a canonical model, and writes to the target system. Incremental filters and durable watermarks limit repeated reads.
Implementation sequence
ServiceNow SOAP APIs
ServiceNow supports table-oriented and scripted SOAP services, as well as SOAP-based outbound messages for selected integrations. SOAP is particularly relevant when a legacy enterprise system requires a WSDL-based contract.
Martini implementation pattern
Martini implementation pattern: a workflow consumes the SOAP operation, parses the XML response or fault, maps the service contract to an internal model, and routes successful and failed messages independently. REST remains the preferred approach for new integrations when available.
Implementation sequence
ServiceNow outbound callbacks
ServiceNow can initiate outbound HTTP calls through configured outbound REST messages, flows, events, business rules, workflow activities, and selected application processes. Callback coverage is configured for selected events rather than automatically available for every table change.
Martini implementation pattern
Martini implementation pattern: Martini exposes a secured REST API endpoint, validates the ServiceNow request and event scope, applies deduplication and business rules, and orchestrates downstream processing. The ServiceNow application must explicitly configure the relevant trigger and endpoint.
Implementation sequence
Import Sets and batch processing
Import Set API, transform maps, scheduled imports, asynchronous processing, and REST Batch API patterns support staged validation and higher-volume data loading. Exact availability and behavior depend on the instance and release.
Martini implementation pattern
Martini implementation pattern: a workflow validates source rows, submits a controlled batch or Import Set payload, tracks processing outcomes, and separates rejected data from successful results. This avoids using individual Table API requests as the only strategy for large loads.
Implementation sequence
ServiceNow Attachment API
The Attachment API supports file and attachment metadata operations associated with ServiceNow records. Parent-record permissions, attachment permissions, content type, and file-size restrictions affect the operation.
Martini implementation pattern
Martini implementation pattern: a workflow retrieves or receives the binary content, validates metadata and access, associates the file with the correct table and record identifier, and records a checksum or source identifier to prevent duplicate uploads.
Implementation sequence
Common ServiceNow App Engine integration patterns
Pattern 1: Synchronize App Engine requests
When to use this pattern
Use this pattern when custom-table records or sc_req_item data must be synchronized with another business application on a scheduled or incremental basis. It is suitable for customer, service-request, approval, or operational workflows that require controlled upserts.
Integration direction
Example Mapping
| ServiceNow App Engine Field | Canonical Field | Target Field |
|---|---|---|
| sys_id | sourceRecordId | externalReference |
| sys_updated_on | lastModifiedAt | updatedAt |
| short_description | summary | name or subject |
| assignment_group | assignmentGroupId | ownerId |
Martini implementation pattern
A scheduled Martini workflow calls the Table API with an incremental filter, follows pagination, resolves reference fields, and maps choice values to the target model. It applies validation and upsert rules, stores sys_id and external identifiers, uses an overlap window for timestamp consistency, and routes transient failures to retry handling.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and incremental synchronization
- data mapping
- business rules
- error handling
Pattern 2: Route ServiceNow events to downstream systems
When to use this pattern
Use this pattern when selected incident, change_request, or custom-table events must trigger notifications, case updates, collaboration actions, or downstream workflows. It requires ServiceNow configuration for the relevant flow, event, business rule, or outbound REST message.
Integration direction
Example Mapping
| ServiceNow App Engine Field | Canonical Field | Target Field |
|---|---|---|
| sys_id | sourceId | issue or message correlationId |
| number | displayReference | externalKey |
| priority | priority | severity |
| state | lifecycleStatus | status |
Martini implementation pattern
ServiceNow calls a secured Martini REST endpoint for the configured event set. Martini authenticates and validates the payload, rejects duplicates, retrieves additional data when needed, maps state and priority values, and invokes the downstream API. Failed deliveries are classified as transient or data-quality errors and retained for retry or review.
Martini capabilities used
- API exposure
- webhook consumption
- request validation
- data transformation
- deduplication
- error routing
Pattern 3: Bulk load data into an App Engine application
When to use this pattern
Use this pattern for larger or staged loads where rows require validation, transformation, rejection handling, or controlled asynchronous processing. Import Sets and transform maps are preferable to many individual synchronous Table API calls when volume increases.
Integration direction
Example Mapping
| ServiceNow App Engine Field | Canonical Field | Target Field |
|---|---|---|
| external_id | sourceIdentifier | u_external_id |
| worker_id | personIdentifier | u_worker |
| effective_date | effectiveDate | u_effective_date |
| status | sourceStatus | u_status |
Martini implementation pattern
Martini receives or retrieves the source batch, validates required fields and reference values, transforms rows to the Import Set contract, and submits a controlled load. The workflow tracks import and transform outcomes, retries transport failures, and stores rejected rows with enough context for correction and replay.
Martini capabilities used
- workflow orchestration
- batch processing
- mapping and transformation
- validation
- asynchronous processing
- retry handling
Pattern 4: Synchronize ServiceNow attachments
When to use this pattern
Use this pattern when documents associated with incidents, requests, change requests, or custom application records must be copied to a document, case, or collaboration platform, or when external files must be attached to ServiceNow records.
Integration direction
Example Mapping
| ServiceNow App Engine Field | Canonical Field | Target Field |
|---|---|---|
| sys_attachment.sys_id | attachmentId | sourceDocumentId |
| file_name | fileName | name |
| content_type | mimeType | contentType |
| table_sys_id | parentRecordId | caseReference |
Martini implementation pattern
Martini retrieves attachment metadata and binary content through supported APIs, validates size and MIME type, maps the parent record, and transfers the file to the target. It records checksums or source identifiers, avoids duplicate uploads, and routes permission, size, or transport failures separately.
Martini capabilities used
- API consumption
- file handling
- binary data processing
- data mapping
- idempotency
- error handling
Applications commonly integrated with ServiceNow App Engine
ServiceNow App Engine can participate in broader enterprise workflows involving customer operations, enterprise resource planning, workforce data, collaboration, development, and analytics. The exact tables and processes depend on the App Engine application and ServiceNow instance configuration.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customer, account, case, or service-request context with ServiceNow workflows and App Engine applications. | Salesforce → Martini → ServiceNow App Engine | Martini consumes Salesforce and ServiceNow APIs, correlates stable identifiers, maps customer and case fields, applies status rules, and performs bidirectional upserts with retry and duplicate handling. |
| Microsoft Dynamics 365 | Coordinate customer-service, field-service, and business-process data with ServiceNow workflows. | Microsoft Dynamics 365 → Martini → ServiceNow App Engine | A Martini workflow retrieves changed records from both systems, normalizes reference and choice values, routes updates according to ownership rules, and records correlation identifiers for safe retries. |
| SAP S/4HANA | Exchange approval, procurement, asset, master-data, and operational status information with custom ServiceNow applications. | SAP S/4HANA → Martini → ServiceNow App Engine | Martini consumes the relevant SAP interfaces and ServiceNow REST or Import Set endpoints, validates required fields, transforms business objects, and routes rejected rows for review. |
| Workday | Synchronize worker, organization, manager, and lifecycle information used by employee-facing App Engine applications. | Workday → Martini → ServiceNow App Engine | Martini schedules incremental worker synchronization, maps Workday identifiers to ServiceNow users and groups, validates reference relationships, and sends workflow outcomes back where required. |
| Jira | Synchronize development issues, incidents, change records, and delivery status across engineering and service processes. | Jira → Martini → ServiceNow App Engine | Martini receives selected ServiceNow callbacks or polls incremental changes, maps incidents and change requests to Jira issues, applies transition rules, and handles conflicting or repeated updates. |
| Microsoft Teams | Deliver ServiceNow approvals, notifications, and task updates to collaboration channels, with selected actions flowing back. | ServiceNow App Engine → Martini → Microsoft Teams | A Martini workflow receives configured ServiceNow events, formats an actionable Teams message through the applicable endpoint, validates callbacks, and updates the originating ServiceNow record when permitted. |
| NetSuite | Exchange customer, order, billing, and operational data with custom ServiceNow applications. | NetSuite → Martini → ServiceNow App Engine | Martini orchestrates NetSuite and ServiceNow API calls, maps external identifiers to sys_id values, uses Import Sets for larger loads, and separates transient failures from data-quality errors. |
| Snowflake | Publish curated ServiceNow and App Engine data for reporting, analytics, and operational analysis without direct SQL access to ServiceNow. | ServiceNow App Engine → Martini → Snowflake | Martini extracts approved tables through supported APIs or exports, applies field-level filtering and transformations, loads curated datasets, and tracks watermarks and failed batches. |
How to build a ServiceNow App Engine integration in Martini
Objective
Establish environment-specific access to the ServiceNow instance using the authentication method approved for the API and the least-privileged integration user.
Instructions in Martini
- Select REST or SOAP based on the ServiceNow contract
- Store credentials, OAuth configuration, and certificates in Martini secrets
- Confirm roles, table permissions, field ACLs, application scope, and cross-scope privileges
- Test access with the actual integration user
Objective
Select a scheduler, API request, or configured ServiceNow callback that matches the synchronization latency and event coverage required by the process.
Instructions in Martini
- Use a scheduler for incremental polling or reconciliation
- Expose a Martini REST endpoint for selected ServiceNow callbacks
- Define the supported table, event, and retry scope
- Capture a durable watermark or event identifier
Objective
Obtain the relevant ServiceNow resource while controlling query size, pagination, reference lookups, and incremental boundaries.
Instructions in Martini
- Request only required fields where supported
- Use stable ordering and bounded pages
- Filter by sys_updated_on or another durable watermark
- Use Import Sets or batch patterns for larger loads
Objective
Coordinate calls, enrichment, branching, asynchronous processing, and target writes in a maintainable Martini workflow.
Instructions in Martini
- Separate transport, validation, transformation, and persistence stages
- Add branches for accepted, rejected, and retryable outcomes
- Use correlation identifiers across every external call
- Keep source and target status visible for replay
Objective
Convert ServiceNow custom-table, platform-table, reference, choice, and attachment data into the target model without relying on unstable display values.
Instructions in Martini
- Map sys_id and external identifiers explicitly
- Translate choice values using controlled mappings
- Validate required fields and reference relationships
- Apply schema and business validation before writing
Objective
Create or update downstream objects and preserve an auditable relationship between ServiceNow identifiers and target identifiers.
Instructions in Martini
- Use deterministic upsert logic where supported
- Apply business rules for ownership, state, and duplicate prevention
- Confirm successful writes before advancing the watermark
- Record attachment and batch outcomes separately
Common ServiceNow App Engine data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Custom application | An App Engine application containing application-specific tables, workflows, fields, and access rules. | Salesforce, Microsoft Dynamics 365, SAP S/4HANA, Jira | Martini treats the application’s published APIs and table permissions as the contract, with environment-specific mappings and validation. |
| Custom table | Stores application-specific requests, approvals, operational data, or other business records. | ERP, CRM, analytics platforms, and databases | Martini uses Table API, scripted REST, or Import Set patterns, maps reference and choice fields, and performs identifier-based upserts. |
| sys_user | Represents requesters, approvers, assignees, and integration identities. | Workday, Microsoft Teams, Salesforce, identity platforms | Martini maps stable sys_id or external identifiers and validates roles, ACLs, and reference relationships before writing. |
| sys_user_group | Supports assignment, approvals, routing, and access control. | Workday, Jira, Microsoft Teams, downstream workflow systems | Martini synchronizes group identifiers and membership-related attributes where permitted, applying controlled reference resolution. |
| incident | Tracks operational or service-desk incidents exchanged with App Engine workflows and external case systems. | Jira, Salesforce, Microsoft Teams, analytics platforms | Martini receives selected callbacks or polls incremental changes, maps priority and state values, and applies idempotent status updates. |
| change_request | Represents change-management work, approvals, scheduling, and implementation status. | Jira, SAP S/4HANA, Microsoft Teams | Martini applies approval and transition rules, preserves correlation identifiers, and routes invalid or conflicting changes for review. |
Authentication and security considerations
Authentication and authorization
ServiceNow supports OAuth 2.0, Basic Authentication, authentication profiles, and mutual TLS for applicable web-service scenarios. The effective access decision also depends on roles, table and field ACLs, application access settings, OAuth scopes, and cross-scope privileges.
Martini should store environment-specific credentials, tokens, and certificates in secrets rather than workflow definitions. Use a least-privileged ServiceNow integration user and test with that identity instead of an administrator account.
- Confirm access to every custom table, field, reference, and attachment.
- Validate application-scope and cross-scope permissions for App Engine tables.
- Restrict exposed Martini endpoints and validate callback signatures or credentials where configured.
Operational considerations for ServiceNow App Engine integrations
Reliability and operations
ServiceNow integrations should use bounded concurrency, pagination, incremental filters, and exponential backoff for throttling or transient server responses. Import Sets, transform maps, batch operations, and scheduled processing are generally more suitable than individual Table API calls for large volumes.
- Use sys_updated_on with an overlap window, or a timestamp and sys_id combination, for incremental synchronization.
- Store sys_id, external identifiers, event IDs, and attachment checksums to prevent duplicates.
- Separate authentication, ACL, validation, reference, throttling, and server-side business-rule failures.
- Version mappings for custom-table and choice-value changes across development, test, and production instances.
- Test with realistic ACLs, reference fields, attachments, pagination, retries, and partial batch outcomes.
Why use Martini instead of scripts or point-to-point integrations?
A maintainable integration layer
Scripts and point-to-point interfaces can address a single ServiceNow exchange, but they often duplicate authentication, pagination, transformation, retry, and monitoring logic. Martini provides a workflow-based integration layer for coordinating ServiceNow APIs, callbacks, Import Sets, attachments, and downstream systems.
- Centralize mappings, validation, business rules, and reusable orchestration.
- Expose controlled REST APIs for ServiceNow outbound calls and other consumers.
- Support scheduled, event-driven, batch, and API-led integration patterns.
- Separate transient failures from data-quality errors and support controlled replay.
- Keep credentials and environment-specific configuration outside implementation logic.
Frequently asked questions
ServiceNow App Engine integrations generally use ServiceNow REST APIs for platform and custom-table data, SOAP services for legacy or WSDL-based contracts, configured outbound REST callbacks, Import Sets, batch processing, and the Attachment API. Authentication and access are controlled through OAuth 2.0, Basic Authentication, certificates where applicable, roles, ACLs, and application-scope permissions.
Yes. Martini can consume ServiceNow REST and SOAP APIs, expose REST endpoints for configured ServiceNow outbound calls, receive webhook-style callbacks for selected events, and orchestrate mappings, validation, synchronization, attachment handling, retries, and error routing. A dedicated native Martini connector is not documented in the supplied information.
No. A dedicated ServiceNow App Engine connector is not required. Martini can use ServiceNow’s confirmed REST APIs, SOAP services, configured outbound callbacks, Import Set interfaces, Attachment API, and authentication methods through workflows and exposed APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate ServiceNow App Engine with Martini. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ServiceNow, ServiceNow IntegrationHub or other ServiceNow features, cloud infrastructure, API usage, or third-party systems.
REST is generally the preferred approach for new integrations because ServiceNow provides Table, Import Set, Attachment, Aggregate, Batch, scripted REST, and application-facing REST APIs. SOAP remains appropriate when an existing enterprise system requires a WSDL-based contract or legacy service interface.
Yes, for selected configured processes. ServiceNow can make outbound REST calls from flows, business rules, events, workflow activities, or outbound REST messages, and Martini can expose a REST endpoint to receive them. This is not universal webhook coverage for every table change; the relevant event and callback must be explicitly configured.
Martini can use scheduled incremental polling with sys_updated_on or another durable watermark, selected callbacks, or bulk Import Set and batch patterns. Workflows handle pagination, overlap windows, reference resolution, deterministic upserts, correlation identifiers, validation, and retryable versus data-quality failures.
Martini maps custom and standard tables into canonical models, translates choice and reference values, validates payloads, and applies business rules before writing. Workflows can distinguish authentication, ACL, throttling, validation, and server errors, while storing sys_id, external identifiers, event IDs, or checksums to make retries idempotent. Martini can also expose an API façade for downstream applications or ServiceNow callback flows.
Related Martini documentation
Workflows
Plan your ServiceNow App Engine integration
Use Martini to connect ServiceNow App Engine applications and tables with enterprise systems through secure APIs, workflows, callbacks, batch processing, and reusable data mappings.