Ellipse Gradient for Header

Azure Communication Services Integration Guide

Connect Azure Communication Services SMS, email, chat, calling, identity, and phone-number capabilities with enterprise workflows through REST APIs and Azure Event Grid notifications.

Azure Communication Services integration options at a glance

Azure Communication Services provides workload-specific REST APIs for SMS, email, chat, calling, phone numbers, identity, recording, media, and resource administration. Selected workloads publish event notifications through Azure Event Grid, which can deliver SMS, chat, calling, email, and other supported events to HTTPS endpoints. SMS supports multi-recipient requests, while email and calling commonly use asynchronous processing. Authentication can use Microsoft Entra ID, managed identities, service principals, access keys, connection strings, user access tokens, or workload-specific HMAC signing. Martini can consume these APIs, expose endpoints for Event Grid notifications, map communication payloads, and orchestrate retries and status reconciliation.

Integration pointSupported by Azure Communication Services?Common use casesHow Martini supports it
REST APIsYesACS provides workload-specific APIs for SMS, email, chat, calling, phone numbers, identity, recording, media, and resource administration.Martini can consume the relevant ACS REST API, configure authentication, map requests and responses, and orchestrate multi-step workflows.
Webhooks and outbound callbacksLimitedAzure Event Grid delivers selected SMS, chat, calling, email, recording, and media-related notifications to supported handlers, including HTTPS endpoints.Martini can expose a REST endpoint for Event Grid delivery, validate events, deduplicate them, and route them into workflows.
Bulk, asynchronous, and batch operationsLimitedSMS can target multiple recipients in a request, while email and calling commonly return asynchronous identifiers or use callbacks and events.Martini can fan out within controlled limits, persist operation identifiers, correlate callbacks, and retry transient failures.
File and attachment APIsLimitedACS Email supports message attachments. MMS scenarios may use media URLs where supported, while general files are typically stored in Azure Blob Storage or another service.Martini can validate attachment metadata, retrieve or reference external files, and map supported content into email or communication requests.
AuthenticationYesSupported patterns include Microsoft Entra ID, managed identities, service principals, OAuth 2.0 tokens, access keys, connection strings, user access tokens, and selected HMAC signatures.Martini can manage environment-specific credentials and secrets, apply API authentication, and keep signing material outside workflow payloads.
SDKsYesMicrosoft provides SDKs for selected SMS, email, chat, calling, identity, phone-number, and Call Automation workloads.Martini can call documented REST APIs directly and use custom JVM-compatible logic where SDK-specific behavior or complex signing is required.
Database and analytics accessLimitedACS uses Azure Monitor, diagnostic logs, Log Analytics, Azure Resource Graph, and workload reporting rather than a conventional application database interface.Martini can consume relevant Azure monitoring or reporting APIs and store normalized operational results in a target database.
MessagingNot applicableThe supplied ACS integration surface is based on REST APIs and Azure Event Grid rather than a direct ACS messaging-broker interface.Martini can orchestrate Event Grid notifications through exposed APIs and workflows; no ACS-native broker interface is confirmed.

How Azure Communication Services exposes data and business events

Azure Communication Services REST APIs

ACS publishes separate REST API surfaces for SMS, chat, email, calling, phone numbers, identity, recording, media, and resource administration. Endpoint paths and API versions vary by workload, so each implementation must use the relevant reference.

Martini implementation pattern

Martini implementation pattern: Martini authenticates to the selected ACS API, builds a workload-specific request, maps the response into a canonical business model, and persists identifiers needed for later reconciliation. Workflows can apply validation, routing, retries, and downstream updates.

Implementation sequence

Authenticate to the selected ACS workload API
Build the workload-specific request
Submit the request and capture the ACS identifier
Map the response to the canonical business model
Apply validation and business rules
Write the result to the target system

Azure Event Grid notifications

Selected ACS workloads publish notifications through Azure Event Grid, including SMS delivery and inbound events, chat changes, calling events, and email delivery status. Event coverage depends on workload, resource, and API version.

Martini implementation pattern

Martini implementation pattern: Martini exposes an HTTPS API endpoint for Event Grid delivery, validates subscription handshakes and event structure, deduplicates event IDs, and routes supported event types into workflows. Event Grid delivery should be treated as asynchronous and potentially at least once.

Implementation sequence

Receive the Event Grid notification
Validate the subscription handshake or event structure
Check the event type and supported resource
Reject or quarantine malformed events
Deduplicate using the event and ACS identifiers
Map the event to the originating business transaction

SMS asynchronous processing

ACS SMS supports multiple recipients in a request and provides delivery reports or events where the selected capability supports them. Regional, sender, recipient, and service limits apply.

Martini implementation pattern

Martini implementation pattern: Martini validates recipient formats and policy, submits controlled batches, stores the response identifiers, and waits for supported delivery notifications. Retry and reconciliation logic prevents a submission timeout from automatically creating duplicate messages.

Implementation sequence

Validate recipients and sender capabilities
Group recipients within approved limits
Submit the SMS request
Store message and business correlation identifiers
Process delivery reports where available
Reconcile uncertain submissions before retrying

Email delivery status

ACS Email accepts outbound messages with recipients, content, and supported attachments. Submission and final delivery are separate states, with delivery-status notifications available for supported scenarios.

Martini implementation pattern

Martini implementation pattern: Martini builds and submits the email request, records its operation or message identifier, and consumes delivery events to normalize queued, delivered, bounced, or failed states for a target application or operational store.

Implementation sequence

Validate sender, recipients, content, and attachments
Submit the email request
Store the operation or message identifier
Receive supported delivery-status events
Normalize the delivery state
Update the originating business object

Calling and Call Automation callbacks

Calling and Call Automation operations can be asynchronous and may use callbacks or events for progress, completion, recording, or media-related activity where supported.

Martini implementation pattern

Martini implementation pattern: Martini exposes a controlled API for initiating or coordinating supported calling operations, stores call correlation data, and processes callbacks through business rules for case updates, escalation, and follow-up notifications.

Implementation sequence

Receive the call-control request
Validate the caller, destination, and operation
Invoke the supported ACS calling API
Store the call and business correlation identifiers
Receive and validate callbacks or events
Apply completion, escalation, or retry rules

Common Azure Communication Services integration patterns

Pattern 1: Orchestrate customer notifications

When to use this pattern

Use this pattern when an order, case, service, or customer event in another enterprise application should trigger an ACS SMS or email notification with a traceable outcome.

Integration direction
Business application
Martini
Azure Communication Services
Example Mapping
Azure Communication Services FieldCanonical FieldTarget Field
customer.phoneNumberrecipient.phoneNumbersms.to
customer.emailrecipient.emailemail.recipients
notification.bodymessage.contentsms.message or email.body
business.idcorrelationIdworkflow correlation
Martini implementation pattern

Martini receives the source event, validates consent and recipient format, selects SMS or email according to business rules, invokes the appropriate ACS REST API, stores the returned identifier, and processes later status events. Transient failures are retried without resubmitting an uncertain request until reconciliation is complete.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • business rules
  • secrets management
  • error handling

Pattern 2: Route inbound SMS to a case platform

When to use this pattern

Use this pattern when inbound SMS events should create or update customer cases, tickets, or conversations in a downstream application.

Integration direction
Azure Communication Services
Martini
ServiceNow
Example Mapping
Azure Communication Services FieldCanonical FieldTarget Field
data.fromsender.phoneNumbercaller or requester
data.messagemessage.contentdescription
data.messageIdsourceMessageIdexternal reference
event.ideventIddeduplication key
Martini implementation pattern

ACS publishes a supported event through Event Grid, Martini validates the event and deduplicates it, then resolves the sender and routes the message to the appropriate case or ticket workflow. Unsupported or malformed events are quarantined, while downstream failures follow controlled retry handling.

Martini capabilities used
  • REST API exposure
  • webhook handling
  • workflow orchestration
  • mapping and transformation
  • validation
  • duplicate prevention

Pattern 3: Reconcile email delivery status

When to use this pattern

Use this pattern when an application needs reliable delivery-state updates for transactional ACS email rather than treating submission acceptance as final delivery.

Integration direction
Azure Communication Services
Martini
Salesforce
Example Mapping
Azure Communication Services FieldCanonical FieldTarget Field
messageIdcommunicationIdSalesforce communication reference
statusdeliveryStatusactivity status
recipientrecipient.addressContact email
eventTimestatusTimestampactivity timestamp
Martini implementation pattern

Martini receives supported ACS email delivery events, normalizes status values such as queued, delivered, bounced, and failed, and updates the originating application using the stored correlation identifier. Event IDs and communication IDs provide duplicate protection and auditability.

Martini capabilities used
  • event-driven workflows
  • data mapping
  • business rules
  • API consumption
  • error handling
  • logging

Pattern 4: Coordinate Call Automation callbacks

When to use this pattern

Use this pattern when a business application needs to initiate supported ACS calling operations and react to asynchronous call progress, completion, or media events.

Integration direction
ServiceNow
Martini
Azure Communication Services
Example Mapping
Azure Communication Services FieldCanonical FieldTarget Field
case.numberbusinessCorrelationIdcall context
call.todestinationACS call participant
callback.eventTypecallStatecase activity status
call.idproviderCallIdexternal call reference
Martini implementation pattern

Martini exposes a controlled API for the calling request, validates policy and destination data, invokes the ACS operation, and receives callbacks through a separate endpoint. The workflow applies timeout, escalation, duplicate-event, and retry rules before updating the case.

Martini capabilities used
  • API exposure
  • workflow orchestration
  • API consumption
  • correlation
  • business rules
  • error handling

Applications commonly integrated with Azure Communication Services

Azure Communication Services is commonly placed behind enterprise applications that need transactional SMS, email, chat, voice, or video communication. The following are practical API-led integration patterns; direct native integrations are not implied unless specifically stated.

Application Scenario Direction Martini Pattern
Salesforce Send customer notifications and update Leads, Contacts, Cases, or Opportunities with communication and delivery status. Salesforce → Martini → Azure Communication Services Martini receives a Salesforce event or scheduled extract, maps the business payload to the selected ACS SMS or email API, stores the returned identifier, and processes supported Event Grid delivery notifications back into Salesforce.
Microsoft Dynamics 365 Send notifications and associate communication outcomes with Contacts, Accounts, Cases, or Activities. Microsoft Dynamics 365 → Martini → Azure Communication Services A Martini workflow consumes Dynamics data, validates recipients and message content, invokes the appropriate ACS REST API, and correlates later delivery events with the originating Dynamics activity.
ServiceNow Send incident or service-request notifications and record delivery outcomes against incidents or tasks. ServiceNow → Martini → Azure Communication Services Martini receives ServiceNow events or polls selected records, applies notification rules, invokes ACS, and updates ServiceNow after delivery events or failure states are received.
Zendesk Notify customers about ticket changes and route inbound SMS or communication events into Tickets and Users. Zendesk → Martini → Azure Communication Services Martini maps Zendesk ticket and user data to ACS messages, then exposes an API for Event Grid notifications and maps inbound communication outcomes back to Zendesk.
Shopify Send order, fulfillment, delivery, or customer notifications through SMS or email. Shopify → Martini → Azure Communication Services A Martini workflow consumes Shopify order or fulfillment events, applies customer-consent and recipient validation rules, invokes ACS, and records message identifiers for reconciliation.
NetSuite Trigger transactional notifications from sales orders, invoices, or fulfillment events and retain communication results. NetSuite → Martini → Azure Communication Services Martini receives NetSuite business events or scheduled data, transforms transaction details into an ACS email or SMS request, and updates NetSuite with accepted and subsequent delivery statuses.
Workday Send employee or candidate notifications and route communication status to related business processes. Workday → Martini → Azure Communication Services Martini consumes approved Workday data, applies recipient and message policies, calls ACS, and writes correlation and status information to the relevant Workday process or supporting store.
Jira Send issue or operational notifications through SMS or email and use communication results in workflow automation. Jira → Martini → Azure Communication Services Martini consumes Jira issue events, evaluates notification rules, invokes ACS, and processes supported Event Grid events to update Jira or an operational data store.

How to build a Azure Communication Services integration in Martini

Objective

Establish environment-specific access to the required ACS workload and keep credentials separate from workflow data.

Instructions in Martini

  • Select Microsoft Entra ID, managed identity, service principal, access key, connection string, user access token, or required HMAC signing based on the workload.
  • Store keys, client secrets, connection strings, and signing material in Martini secrets configuration.
  • Separate Azure Resource Manager permissions from Communication Services data-plane permissions.

Objective

Select an event, API request, or schedule that matches the communication process.

Instructions in Martini

  • Use an inbound application event or Martini API for transactional notifications.
  • Expose a Martini REST endpoint for supported Azure Event Grid notifications.
  • Use a scheduler for reconciliation, reporting, or long-running synchronization.

Objective

Obtain ACS resources, messages, statuses, or events using the workload-specific interface.

Instructions in Martini

  • Consume the relevant SMS, email, chat, calling, phone-number, identity, or monitoring API.
  • Follow continuation tokens or next links for paginated resources.
  • Capture event, message, operation, call, and business correlation identifiers.

Objective

Coordinate the ACS call, downstream operations, asynchronous callbacks, and status reconciliation.

Instructions in Martini

  • Separate submission workflows from delivery or callback-processing workflows.
  • Route SMS, email, chat, and calling payloads through workload-specific branches.
  • Apply controlled concurrency and avoid unbounded fan-out.

Objective

Convert ACS schemas into canonical business objects and target application models.

Instructions in Martini

  • Keep SMS, email, chat, and calling mappings separate because their schemas and status models differ.
  • Normalize phone numbers, delivery states, timestamps, identifiers, and event metadata.
  • Preserve useful unknown fields where practical for forward compatibility.

Objective

Enforce recipient, consent, sender, regional, attachment, and communication-status policies.

Instructions in Martini

  • Validate E.164 formatting and country-specific restrictions before sending.
  • Check sender and domain configuration for email workflows.
  • Use stable business correlation keys and reject unsupported event types safely.

Common Azure Communication Services data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Communication Services resourcesRepresent the Azure service resource, endpoint, keys, identity configuration, and phone-number associations.Azure Resource Manager, configuration stores, monitoring platformsMartini can retrieve or administer resource-related data through documented Azure APIs and keep credentials in secrets rather than payloads.
Communication Services identitiesIdentify applications or users for chat, calling, and short-lived client access tokens.Identity platforms, chat applications, calling applicationsMartini can create or manage supported identities, map identity references, and coordinate token issuance workflows.
Phone numbersProvide SMS, voice, or telephony capabilities subject to country, sender, and service restrictions.Azure administration, CRM, contact-center, notification applicationsMartini can synchronize phone-number metadata, validate E.164 values, and apply regional and capability rules before sending.
Chat threads and chat messagesRepresent conversations, participants, and messages in ACS Chat.CRM, support platforms, collaboration applicationsMartini can consume Chat APIs, follow pagination, normalize thread and message events, and synchronize selected changes.
SMS messagesRepresent outbound and inbound text messages and delivery status information.Salesforce, ServiceNow, Zendesk, Dynamics 365, operational storesMartini maps recipients and content to SMS requests, stores ACS identifiers, and processes delivery or inbound events where supported.
Email messagesRepresent outbound email submissions, recipients, content, attachments, and delivery status.CRM, ERP, customer platforms, operational storesMartini validates recipients and attachments, submits email requests, stores operation identifiers, and reconciles asynchronous delivery states.

Authentication and security considerations

Authentication options

Azure Communication Services supports Microsoft Entra ID, managed identities, service principals, OAuth 2.0 access tokens, access keys, connection strings, short-lived user access tokens, and workload-specific HMAC signing. The applicable option depends on the ACS API or SDK.

Secret protection

Martini can keep Communication Services keys, connection strings, client secrets, and signing material in environment-specific secrets rather than workflow payloads. Prefer Microsoft Entra-based access where supported, restrict Azure RBAC permissions, and rotate long-lived keys.

Event security

Event Grid endpoints should validate subscription handshakes, event structure, event type, subject, resource, and event ID. Apply replay protection and reject unsupported or malformed notifications safely.

Operational considerations for Azure Communication Services integrations

Rate limits and retries

Apply workload-specific throttling for HTTP 429 and transient 5xx responses. SMS, email, phone numbers, and calling have different regional, sender, recipient, and resource limits; avoid unbounded workflow fan-out.

Pagination and checkpoints

Phone numbers, chat threads, messages, participants, and reporting results may be paginated. Follow the documented continuation mechanism and store a checkpoint for long-running imports.

Idempotency and eventual consistency

Accepted SMS, email, or calling requests do not necessarily represent final delivery or completion. Store ACS identifiers and business correlation keys, deduplicate Event Grid notifications, and reconcile uncertain submissions before retrying.

Versions and schemas

ACS workload APIs have separate endpoint formats and API versions. Pin and test versions, keep SMS, email, chat, and calling mappings distinct, and preserve unknown fields where practical.

Regional and payload rules

Validate E.164 phone numbers, sender capabilities, country restrictions, domain configuration, attachment size, MIME types, media URLs, and expiration behavior before submission.

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

Coordinate complete integration processes

Scripts often handle a single API call, while Martini can orchestrate the full lifecycle: receive a business event, authenticate to ACS, transform the payload, apply communication rules, submit the request, and process later delivery or callback events.

Keep integrations maintainable

Reusable workflows, explicit mappings, environment-specific secrets, validation, correlation, and centralized error handling reduce the operational burden of point-to-point integrations.

Support multiple workloads

Martini can keep SMS, email, chat, calling, identity, phone-number, and monitoring flows distinct while exposing consistent APIs and canonical business behavior to enterprise applications.

Operate with visibility

Workflow logging, controlled retries, duplicate protection, status reconciliation, and Azure monitoring integrations provide a clearer operational model than isolated scripts.

Frequently asked questions

How can Azure Communication Services be integrated with enterprise systems?

Azure Communication Services can be integrated through workload-specific REST APIs, Microsoft Azure SDKs, and selected event notifications delivered through Azure Event Grid. Enterprise workflows can send SMS and email, manage chat and calling operations, administer phone numbers and identities, and process delivery or lifecycle events.

Can Martini integrate with Azure Communication Services?

Yes. Martini can consume Azure Communication Services REST APIs, expose an HTTPS API for supported Azure Event Grid notifications, invoke relevant Azure monitoring or reporting APIs, and orchestrate mapping, validation, retries, and downstream updates.

Do I need a connector to integrate Azure Communication Services with Martini?

No. A dedicated Azure Communication Services connector is not required. Martini can use the service's documented REST APIs, supported Event Grid notifications, authentication methods, and workload-specific callbacks.

Is there any extra Lonti cost to integrate Azure Communication Services with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Azure Communication Services. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from Microsoft Azure, infrastructure providers, or other third-party systems based on subscriptions, usage, and deployment model.

Which Azure Communication Services integration methods should be used?

REST APIs are the primary integration method for SMS, email, chat, calling, phone numbers, identity, and related workloads. Use Azure Event Grid for supported event notifications, and use SDK-specific custom logic only where REST APIs do not provide the required behavior. Official GraphQL and SOAP APIs were not confirmed.

Are Azure Communication Services events and webhooks available?

Selected ACS workloads publish events through Azure Event Grid, including SMS delivery or inbound events, chat changes, calling events, and email delivery status. Coverage is workload-specific rather than universal, and Event Grid can deliver supported events to an HTTPS Martini API endpoint.

How does synchronization and data mapping work with Azure Communication Services?

Martini can map ACS identities, phone numbers, SMS messages, email messages, chat threads, calls, and event payloads into canonical business models. Synchronization can be event-driven or scheduled, with pagination, correlation identifiers, delivery-state reconciliation, and workload-specific transformations.

How are errors, retries, and duplicate events handled?

Martini workflows can apply validation, controlled retries for transient HTTP 429 and 5xx responses, logging, quarantine, and downstream error handling. Because Event Grid delivery is asynchronous and potentially at least once, workflows should deduplicate using event IDs and ACS message, operation, call, or thread identifiers. Martini can also expose an API façade for controlled ACS operations and callbacks.

Related Martini documentation

APIs

Events

Transformation

Security

Operations

Connect Azure Communication Services to your enterprise workflows

Use Martini to build secure, observable integrations with Azure Communication Services REST APIs, Azure Event Grid notifications, and related Azure services.

EXPLORE MARTINI
BOOK A DEMO