.png)
ServiceNow Software Asset Management Integration Guide
Integrate ServiceNow Software Asset Management with enterprise systems through ServiceNow REST, import, attachment, and configured outbound integration mechanisms.
ServiceNow Software Asset Management integration options at a glance
ServiceNow Software Asset Management integrations commonly use ServiceNow REST APIs, especially the Table API, for querying and updating supported records. Import Set APIs and Transform Maps support controlled bulk ingestion, while the Attachment API handles license agreements, purchase evidence, and reconciliation files. ServiceNow can also send selected outbound requests through configured business rules, flows, notifications, or outbound REST messages, although universal webhook coverage should not be assumed. OAuth 2.0 and Basic Authentication are common options, subject to roles and ACLs. Martini can orchestrate scheduled or event-driven workflows, paginate results, transform SAM data, and apply idempotent synchronization logic.
| Integration point | Supported by ServiceNow Software Asset Management? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | ServiceNow Table API and application APIs support querying, inserting, updating, and deleting permitted SAM-related records, with encoded queries, field selection, ordering, and pagination. | Martini can consume ServiceNow REST endpoints, expose reusable APIs, map responses, and orchestrate reads and writes in workflows. |
| GraphQL APIs | Limited | ServiceNow GraphQL capabilities are available for selected releases and use cases, but universal coverage of SAM objects should not be assumed. | Martini can consume GraphQL where the target instance exposes the required SAM schema, with REST remaining the safer baseline. |
| SOAP APIs | Legacy | ServiceNow SOAP web services may support existing enterprise integrations and legacy operations. | Martini can consume SOAP services when required, but new SAM integrations should generally prefer supported REST operations. |
| Webhooks / outbound callbacks | Limited | Business rules, flows, notifications, and outbound REST messages can send selected entitlement, asset, contract, or reconciliation changes to external endpoints. | Martini can expose an API and receive configured ServiceNow requests, validate events, route them, and record processing outcomes. |
| Bulk / async / batch APIs | Yes | Import Set API, Transform Maps, REST batch patterns, and asynchronous platform processing support larger inventory, discovery, and entitlement loads. | Martini can create controlled batches, submit imports, monitor results, and retry failed rows without treating the load as one transaction. |
| File / attachment APIs | Yes | Attachment API supports license agreements, purchase evidence, reconciliation reports, inventory extracts, and other files associated with ServiceNow records. | Martini can transfer attachments, preserve metadata, calculate or validate content details, and isolate large-file processing from normal record sync. |
| Authentication | Yes | OAuth 2.0 and Basic Authentication are common REST options, with access governed by roles, ACLs, application scopes, and web-service settings. | Martini can use configured authentication and keep credentials and tokens in environment configuration or secrets management. |
| Database access | No | Direct access to the ServiceNow production database is not a normal supported integration method. | Martini should use ServiceNow APIs, import facilities, attachments, or approved exports rather than direct database access. |
How ServiceNow Software Asset Management exposes data and business events
ServiceNow REST APIs
ServiceNow REST APIs, including the Table API, provide the primary standards-based path for querying and updating supported SAM-related tables. Query behavior, fields, tables, and permissions vary by release, installed applications, and customization.
Martini implementation pattern
Martini implementation pattern: Martini authenticates to the ServiceNow instance, calls supported REST resources with encoded filters and pagination, maps records into a canonical model, and writes results to downstream systems or supported ServiceNow endpoints.
Implementation sequence
ServiceNow outbound callbacks
ServiceNow can send selected changes through configured business rules, Flow Designer logic, notifications, or outbound REST messages. This is configuration-dependent and is not a universal webhook for every SAM event.
Martini implementation pattern
Martini implementation pattern: Martini exposes a controlled API endpoint, validates the inbound request, checks event identity and authorization, routes the selected SAM change, and records an outcome. Scheduled reconciliation complements gaps in event coverage.
Implementation sequence
ServiceNow Import Set API
Import Sets and Transform Maps support controlled ingestion when external discovery, inventory, or entitlement data requires validation, normalization, and reconciliation before reaching production SAM tables.
Martini implementation pattern
Martini implementation pattern: Martini receives or retrieves source data, validates and transforms rows, submits manageable Import Set batches, and tracks import results separately from source extraction so individual failures can be replayed.
Implementation sequence
ServiceNow Attachment API
The Attachment API supports files associated with ServiceNow records, including license agreements, purchase evidence, reconciliation reports, and inventory extracts. Permissions, file size, content type, and retention must be confirmed.
Martini implementation pattern
Martini implementation pattern: Martini isolates attachment transfer from ordinary record synchronization, preserves record references and metadata, validates content handling, and retries transfer failures without duplicating successfully stored files.
Implementation sequence
ServiceNow SOAP services
ServiceNow SOAP web services may support legacy enterprise integrations, although REST is generally preferred for new SAM work where the required operation is available.
Martini implementation pattern
Martini implementation pattern: Martini consumes the verified SOAP operation, transforms XML payloads, handles SOAP faults distinctly from business validation errors, and keeps the interface isolated so it can be replaced by REST later.
Implementation sequence
Common ServiceNow Software Asset Management integration patterns
Pattern 1: Synchronize software installations to an optimization platform
When to use this pattern
Use this pattern when ServiceNow is the operational source for discovered software installations and another platform needs current inventory for license optimization or analytics. Incremental extraction and stable identifiers reduce load and duplicate processing.
Integration direction
Example Mapping
| ServiceNow Software Asset Management Field | Canonical Field | Target Field |
|---|---|---|
| cmdb_ci_software.name | installedProductName | softwareName |
| cmdb_ci_software.version | installedVersion | version |
| cmdb_ci.sys_id | configurationItemId | deviceReference |
| sys_updated_on | sourceUpdatedAt | lastModified |
Martini implementation pattern
A scheduled Martini workflow queries cmdb_ci_software and related Configuration Items using sys_updated_on with an overlap window, normalizes product and version values, excludes retired items according to policy, upserts the target using a stable source key, and retries transient failures while preserving the watermark.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination
- data mapping
- business rules
- error handling
Pattern 2: Load external discovery data through Import Sets
When to use this pattern
Use this pattern when an endpoint or inventory product supplies data that needs publisher normalization, version parsing, device matching, and duplicate control before ServiceNow SAM records are updated.
Integration direction
Example Mapping
| ServiceNow Software Asset Management Field | Canonical Field | Target Field |
|---|---|---|
| sourceDeviceId | deviceExternalId | cmdb_ci.external_id |
| publisher | publisherName | softwarePublisher |
| productVersion | version | cmdb_ci_software.version |
| installationState | installationStatus | cmdb_ci_software.install_status |
Martini implementation pattern
Martini retrieves source inventory, validates required identifiers, applies normalization and matching rules, rejects ambiguous rows with correlation details, submits accepted records to the Import Set API, and tracks Transform Map outcomes for safe replay.
Martini capabilities used
- workflows
- API consumption
- data transformation
- validation
- batch processing
- error handling
Pattern 3: Synchronize entitlements and contract renewals
When to use this pattern
Use this pattern when procurement or vendor-management data must support ServiceNow entitlement records, or when ServiceNow entitlement and contract status must be shared with a financial or procurement application.
Integration direction
Example Mapping
| ServiceNow Software Asset Management Field | Canonical Field | Target Field |
|---|---|---|
| entitlement.quantity | licensedQuantity | orderedQuantity |
| entitlement.metric | licenseMetric | unitOfMeasure |
| ast_contract.renewal_date | renewalDate | contractRenewalDate |
| publisher | supplierName | supplier |
Martini implementation pattern
Martini retrieves permitted entitlement and contract fields, validates quantities, metrics, supplier references, and dates, maps them into the target procurement model, applies source-of-truth rules, and uses idempotent upserts with a review path for incomplete commercial data.
Martini capabilities used
- API consumption
- data mapping
- validation
- business rules
- workflow orchestration
- retry handling
Pattern 4: Process selected entitlement change events
When to use this pattern
Use this pattern when the ServiceNow instance is configured to send selected entitlement, asset lifecycle, contract, or reconciliation changes through an outbound REST message, flow, or business rule.
Integration direction
Example Mapping
| ServiceNow Software Asset Management Field | Canonical Field | Target Field |
|---|---|---|
| event.record_id | sourceRecordId | externalReference |
| event.record_type | changeType | eventType |
| entitlement.state | entitlementStatus | status |
| sys_updated_on | eventUpdatedAt | lastChangedAt |
Martini implementation pattern
Martini receives the configured callback through an API, authenticates and validates the event, retrieves the current record when the notification is incomplete, applies routing and deduplication rules, updates the target, and relies on scheduled reconciliation for missed events.
Martini capabilities used
- API exposure
- webhook consumption
- workflow orchestration
- business rules
- idempotency
- monitoring
Applications commonly integrated with ServiceNow Software Asset Management
ServiceNow SAM can exchange inventory, entitlement, procurement, contract, and compliance information with endpoint-management, software-intelligence, and procurement products. Exact packaged integration scope depends on the ServiceNow release, installed plugins, licensing, and customer configuration; Martini can implement standards-based integrations using the confirmed APIs and endpoints.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Microsoft Configuration Manager | Import software inventory and device installation data into ServiceNow SAM for normalization and reconciliation. | Microsoft Configuration Manager → Martini → ServiceNow Software Asset Management | Martini retrieves inventory through the available source API or export, normalizes publisher, product, version, and device identifiers, then loads validated data through ServiceNow Import Set APIs or supported REST endpoints with duplicate handling and retry logic. |
| Microsoft Intune | Synchronize managed-device and application inventory for cloud-managed endpoints. | Microsoft Intune → Martini → ServiceNow Software Asset Management | A scheduled Martini workflow retrieves changed Intune data, maps cloud device identifiers to ServiceNow Configuration Items, validates software attributes, and submits controlled batches for SAM processing. |
| Jamf Pro | Provide macOS device and application inventory for software installation and entitlement reconciliation. | Jamf Pro → Martini → ServiceNow Software Asset Management | Martini consumes Jamf inventory data, applies Apple-specific product and version normalization, matches devices using stable identifiers, and upserts installation information through supported ServiceNow APIs or import processing. |
| Tanium | Deliver endpoint inventory and software discovery data to support asset and software normalization. | Tanium → Martini → ServiceNow Software Asset Management | Martini extracts Tanium results incrementally, validates source identifiers and software attributes, routes invalid rows to an error path, and loads accepted discovery data through Import Sets and Transform Maps. |
| Flexera One | Exchange software inventory, normalized product data, entitlement information, or compliance results. | Flexera One → Martini → ServiceNow Software Asset Management | Martini coordinates bidirectional synchronization where required, maps each platform's publisher, product, entitlement, and compliance fields to a canonical model, and uses source ownership rules to prevent update loops. |
| Snow Atlas | Synchronize software inventory, license intelligence, or compliance data with ServiceNow SAM. | Snow Atlas → Martini → ServiceNow Software Asset Management | A Martini workflow retrieves or receives Snow data, enriches it with ServiceNow identifiers, applies reconciliation rules, and writes approved changes while recording watermarks and correlation IDs. |
| SAP Ariba | Share purchasing information that supports software entitlement and contract management. | SAP Ariba → Martini → ServiceNow Software Asset Management | Martini maps purchase orders, suppliers, quantities, and contract references into ServiceNow entitlement or contract processes, validates commercial fields, and returns synchronization status where permitted. |
| Oracle Fusion Cloud Procurement | Exchange purchase order, supplier, contract, and software purchasing information. | Oracle Fusion Cloud Procurement → Martini → ServiceNow Software Asset Management | Martini retrieves approved procurement data, transforms supplier and product identifiers, applies entitlement ownership rules, and loads records through supported ServiceNow REST or import mechanisms. |
How to build a ServiceNow Software Asset Management integration in Martini
Objective
Establish access to the target ServiceNow instance using an approved authentication method and narrowly scoped permissions.
Instructions in Martini
- Configure the ServiceNow base URL and API resources
- Use OAuth 2.0 where approved, or another permitted method
- Store credentials and tokens in Martini environment configuration or secrets management
- Confirm roles, ACLs, application scope, and web-service access
Objective
Select scheduled polling, a configured ServiceNow outbound request, or an API-led invocation based on event coverage and synchronization requirements.
Instructions in Martini
- Use a scheduler for reconciliation and incremental extraction
- Expose a Martini API for selected ServiceNow outbound requests
- Define the event or time boundary and expected payload
- Plan a reconciliation path for missed or unsupported events
Objective
Read supported ServiceNow records or receive inbound data without relying on direct database access.
Instructions in Martini
- Use the Table API or verified application-specific API
- Apply encoded filters, field selection, and pagination
- Use sys_updated_on with an overlap window where appropriate
- Use Import Set or Attachment APIs for bulk and file-oriented flows
Objective
Coordinate extraction, validation, transformation, target writes, checkpoints, and recovery in a maintainable Martini workflow.
Instructions in Martini
- Separate extraction, transformation, and delivery stages
- Persist watermarks and source identifiers
- Route invalid records to a reviewable error path
- Keep attachment processing separate from ordinary record synchronization
Objective
Convert ServiceNow SAM data into the target model while preserving identifiers and applying normalization rules.
Instructions in Martini
- Map Software Models, Entitlements, Installations, CIs, Assets, and Contracts explicitly
- Normalize publisher, product, edition, version, and metric values
- Validate quantities, dates, statuses, and required identifiers
- Use canonical keys to prevent duplicate creation
Objective
Enforce source-of-truth, lifecycle, approval, and reconciliation policies before changing either system.
Instructions in Martini
- Define ownership for each synchronized field
- Handle retired CIs and decommissioned installations
- Reject ambiguous product or device matches
- Prevent event loops in bidirectional flows
Common ServiceNow Software Asset Management data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Software Model | Normalized publisher, product, version, and licensing reference used across SAM. | Procurement platforms, license-optimization tools, analytics platforms | Martini retrieves or updates supported fields through REST, applies product normalization, and preserves ServiceNow identifiers. |
| Software Entitlement | Purchased or allocated rights, quantities, metrics, and entitlement information. | Procurement, finance, vendor-management, and compliance platforms | Martini validates commercial fields, maps entitlement metrics and quantities, and performs idempotent upserts or controlled Import Set loads. |
| Software Installation | Discovered or registered software installed on configuration items. | Endpoint-management, inventory, analytics, and license-optimization products | Martini extracts incremental changes, maps product and device identifiers, and handles retired or decommissioned installations. |
| Configuration Item | Device, server, virtual-machine, and infrastructure context for installations and discovery. | Endpoint-management and asset platforms | Martini matches stable identifiers, enriches installation payloads, and avoids creating duplicate CI relationships. |
| Asset | Financial and lifecycle information related to software or hardware ownership. | Finance, procurement, asset-management, and reporting systems | Martini maps ownership, lifecycle, and external references while respecting ServiceNow ACLs and source-of-truth rules. |
| Contract | Contractual, renewal, supplier, and agreement information supporting entitlement management. | Procurement, finance, vendor-management, and renewal systems | Martini synchronizes approved contract fields, applies date and status validation, and routes incomplete records for review. |
Authentication and security considerations
Authentication and authorization
ServiceNow commonly supports OAuth 2.0 and Basic Authentication for REST integrations, with access constrained by roles, ACLs, application scopes, and web-service settings. Session or platform mechanisms, mutual TLS, and network controls may also be configured by the environment.
Use a dedicated integration account with only the permissions required for the selected SAM tables and APIs. Store client credentials, passwords, access tokens, and refresh tokens in Martini environment configuration or secrets management rather than workflow definitions.
- Confirm table availability and field-level permissions in the target instance.
- Prefer OAuth 2.0 where consistent with organizational policy.
- Do not assume administrative access or direct database access.
Operational considerations for ServiceNow Software Asset Management integrations
Reliable synchronization
ServiceNow instances impose transaction, query, and platform resource controls. Use bounded encoded queries, field selection, pagination, manageable batches, and scheduled loads for large inventory sets. Persist watermarks with an overlap window so updates at extraction boundaries are not missed.
Data quality and idempotency
Software Asset Management depends on normalized publishers, products, editions, versions, metrics, devices, quantities, and contract dates. Use stable source identifiers, explicit matching rules, idempotent upserts, and Import Set transformations to prevent duplicates and safely process ambiguous rows.
Change and failure management
Table schemas, scoped application fields, plugins, and API availability vary by release and customization. Verify mappings with REST API Explorer, tolerate optional fields, test upgrades outside production, and distinguish authentication, ACL, validation, throttling, and temporary service failures. Record correlation IDs and retry only safe transient operations.
Why use Martini instead of scripts or point-to-point integrations?
Beyond point-to-point scripts
Martini provides a workflow-based integration layer for ServiceNow SAM rather than coupling every target directly to ServiceNow. It can consume REST, import, attachment, and selected callback endpoints; expose controlled APIs; and coordinate scheduled reconciliation with event-driven processing.
Reusable workflows centralize authentication, pagination, mapping, normalization, business rules, retries, and monitoring. This makes it easier to support multiple inventory, procurement, and software-intelligence systems while preserving source identifiers, checkpoints, and operational visibility.
- Separate extraction, transformation, validation, and delivery concerns.
- Reuse canonical mappings and error-handling patterns across targets.
- Combine selected outbound events with reliable scheduled reconciliation.
Frequently asked questions
ServiceNow SAM can integrate through supported REST APIs such as the Table API, Import Set API, Attachment API, configured outbound REST messages, business rules, flows, and legacy SOAP services. Scheduled polling is appropriate for broad reconciliation, while selected outbound events can support near-real-time processing.
Yes. Martini can consume ServiceNow REST APIs, submit controlled Import Set loads, transfer attachments, consume verified SOAP services where required, and receive selected outbound requests through a Martini API. No native Martini connector is documented in the supplied materials.
No. A dedicated ServiceNow SAM connector is not required. Martini can use ServiceNow's confirmed REST, import, attachment, authentication, and configured outbound integration mechanisms.
Lonti does not charge an additional per-connector or per-vendor fee to integrate ServiceNow SAM. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ServiceNow, infrastructure, or other third-party systems based on subscription, usage, and deployment model.
The Table API is the general starting point for supported SAM-related tables. The Import Set API is suitable for controlled bulk ingestion and transformation, and the Attachment API is intended for record-associated files. A supported application-specific API may be preferable when the installed SAM implementation exposes one.
ServiceNow can send selected changes through configured outbound REST messages, business rules, flows, notifications, or related platform mechanisms. This is not universal webhook coverage for every SAM event, so the required event types must be configured and verified. Scheduled reconciliation should normally complement the event path.
Martini can run scheduled or event-driven workflows that paginate through ServiceNow results, use incremental fields such as sys_updated_on, map data to a canonical model, normalize products and publishers, apply business rules, and perform idempotent upserts. Import Sets and Transform Maps are useful for larger controlled loads.
OAuth 2.0 or another approved ServiceNow authentication method can be configured with least-privilege roles and ACLs. Martini can distinguish authentication, permission, validation, throttling, and temporary platform failures, apply retry policies, persist correlation IDs, and use stable source identifiers or Import Set matching rules to prevent duplicates.
Related Martini documentation
Integrate ServiceNow Software Asset Management with Martini
Use Martini to build maintainable ServiceNow SAM integrations across REST APIs, Import Sets, attachments, scheduled workflows, and selected outbound events.