.png)
Microsoft Outlook Integration Guide
Connect Microsoft Outlook mail, calendars, contacts, and attachments with enterprise systems through Microsoft Graph REST APIs and selected change notifications.
Microsoft Outlook integration options at a glance
Microsoft Outlook integrations use the Microsoft Graph REST API to work with messages, mail folders, events, calendars, contacts, users, mailbox settings, and attachments. Selected Outlook resources also support Microsoft Graph change notifications, while delta queries enable incremental synchronization. Graph supports JSON batching and attachment upload sessions for applicable scenarios. OAuth 2.0 through Microsoft Entra ID provides delegated and application permissions. Martini can consume these HTTPS endpoints, receive validated notifications through a Martini API, schedule renewals and reconciliation, map Graph JSON to enterprise schemas, and apply retries, pagination, idempotency, and business rules.
| Integration point | Supported by Microsoft Outlook? | Common use cases | How Martini supports it |
|---|---|---|---|
| Microsoft Graph REST APIs | Yes | Read, create, update, delete, move, and send Messages; manage Mail folders, Events, Calendars, Contacts, Users, mailbox settings, and Attachments. | Martini can consume Microsoft Graph HTTPS endpoints from workflows, pass bearer tokens, handle OData pagination, and map JSON responses to downstream systems. |
| Webhooks / change notifications | Limited | Receive notifications for selected Messages, Mail folders, Events, and Users resources when subscribed coverage is available. | Martini can expose an API endpoint or webhook-oriented workflow, handle validation requests, verify client state, retrieve the changed resource, and schedule subscription renewal. |
| Delta queries | Yes | Perform initial and incremental synchronization for applicable Messages, Mail folders, Events, and Contacts scenarios using stored delta links. | Martini can persist synchronization links, process additions, changes, and deletions, and combine delta reconciliation with notifications and scheduled recovery. |
| JSON batching | Yes | Submit multiple Microsoft Graph HTTP requests together to reduce network round trips for suitable workloads. | Martini can construct batch requests and process individual response results, while retaining resource-level retry and throttling handling. |
| File and attachment APIs | Yes | Read and write file, item, and reference Attachments on Messages and Events; use upload sessions for applicable large files. | Martini can transfer attachment metadata and content, transform file names and content types, apply scanning or retention rules, and pass files to downstream APIs. |
| OAuth 2.0 authentication | Yes | Authenticate delegated user workflows or service-to-service integrations with Microsoft Entra ID application permissions and resource-specific scopes. | Martini can securely configure client credentials, tokens, scopes, endpoints, and environment values, then send Microsoft Graph bearer access tokens. |
| SOAP / Exchange Web Services | Legacy | Support transitional Exchange integrations that still depend on Exchange Web Services rather than Microsoft Graph. | Martini can consume documented SOAP services where required, but new Microsoft 365 Outlook integrations should use Microsoft Graph REST APIs. |
| Database access | No | Outlook mailbox data is not exposed as a customer-accessible relational database for direct application integration. | Martini should use Microsoft Graph, change notifications, delta queries, or approved export and compliance mechanisms instead of direct mailbox database access. |
How Microsoft Outlook exposes data and business events
Microsoft Graph REST APIs
Microsoft Graph is the primary integration interface for Microsoft Outlook. Its REST resources cover Messages, Mail folders, Events, Calendars, Contacts, Users, mailbox settings, and Attachments, with supported OData query options for filtering, projection, ordering, and expansion.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with Microsoft Entra ID, calls the required Graph endpoint, follows pagination links, maps the JSON response, applies business rules, and writes the result to an enterprise target. Martini can also expose a controlled API that normalizes Outlook operations for internal consumers.
Implementation sequence
Microsoft Graph change notifications
Microsoft Graph supports change-notification subscriptions for selected Outlook resources, including applicable Messages, Mail folders, Events, and Users scenarios. Notifications are resource-specific, expire, and should not be treated as a complete copy of the changed resource.
Martini implementation pattern
Martini implementation pattern: expose a Martini API endpoint, respond to Graph validation requests, verify the client state, accept the notification, retrieve the current resource from Graph, and route it through the relevant workflow. A scheduled workflow renews subscriptions and reconciles missed notifications.
Implementation sequence
Delta queries
Delta queries provide incremental synchronization for applicable Messages, Mail folders, Events, and Contacts scenarios. An initial request establishes a baseline, and later requests use a stored delta link to identify additions, changes, and deletions.
Martini implementation pattern
Martini implementation pattern: run a baseline workflow, persist the returned next or delta link securely, process each page, and resume from the stored link. If the link becomes invalid or notifications indicate a gap, Martini can initiate a controlled baseline and reconciliation process.
Implementation sequence
Attachments and file content
Outlook Messages and Events can contain file, item, and reference Attachments. Large file attachments may require an upload session, and downstream systems may impose their own size, security, and retention requirements.
Martini implementation pattern
Martini implementation pattern: retrieve attachment metadata and content, decide whether to preserve, scan, store, or forward each file, then map content type and naming conventions to the target API. Failed transfers are retried without duplicating successful attachment writes.
Implementation sequence
JSON batching
Microsoft Graph JSON batching allows multiple HTTP requests in one request and can reduce network round trips. Batching does not remove resource-level throttling and does not make all operations transactional.
Martini implementation pattern
Martini implementation pattern: group compatible Graph requests, submit a batch, inspect each individual response, and route failed operations through resource-aware retry handling. Martini maintains correlation and idempotency information for each request within the batch.
Implementation sequence
Common Microsoft Outlook integration patterns
Pattern 1: Sync Outlook email to a CRM
When to use this pattern
Use this pattern when email activity must be associated with customer or contact records without creating duplicate activities. It is suitable for selected mail folders, filtered senders, or defined retention windows.
Integration direction
Example Mapping
| Microsoft Outlook Field | Canonical Field | Target Field |
|---|---|---|
| id | sourceMessageId | External_Message_ID__c |
| subject | activitySubject | Subject |
| from.emailAddress.address | senderEmail | FromAddress |
| receivedDateTime | receivedAt | ActivityDateTime |
Martini implementation pattern
A scheduled workflow or change-notification workflow retrieves the current Message, follows pagination or delta links, converts body content according to policy, and optionally transfers Attachments. Martini matches the source message ID and applies mailbox, sender, privacy, and retention rules before creating or updating the CRM activity. Throttling, transient failures, and downstream errors use bounded retries and a recoverable error path.
Martini capabilities used
- workflows
- API consumption
- data mapping
- JSON handling
- business rules
- error handling
Pattern 2: Synchronize Outlook calendar events
When to use this pattern
Use this pattern when Outlook Events and Calendars must remain aligned with an enterprise scheduling or customer-management application. The design must define ownership, conflict, cancellation, recurrence, and time-zone behavior.
Integration direction
Example Mapping
| Microsoft Outlook Field | Canonical Field | Target Field |
|---|---|---|
| id | sourceEventId | externalcalendarobjectid |
| subject | eventTitle | subject |
| start.dateTime | startsAt | scheduledstart |
| end.dateTime | endsAt | scheduledend |
Martini implementation pattern
Martini uses Graph delta queries for incremental state and may use change notifications for prompt detection. The workflow normalizes time zones and recurrence, maps attendees and locations, applies ownership and conflict rules, and writes idempotently using the Graph event ID. Cancellations and invalid synchronization links are routed to reconciliation handling.
Martini capabilities used
- workflows
- scheduled synchronization
- API consumption
- data mapping
- business rules
- error handling
Pattern 3: Send governed application email through Outlook
When to use this pattern
Use this pattern when internal applications need outbound email but sender authorization, templates, recipient validation, attachments, and audit controls should be centralized.
Integration direction
Example Mapping
| Microsoft Outlook Field | Canonical Field | Target Field |
|---|---|---|
| request.subject | emailSubject | message.subject |
| request.recipients | toRecipients | message.toRecipients |
| request.body | emailBody | message.body |
| request.attachments | outboundAttachments | message.attachments |
Martini implementation pattern
A Martini API accepts a normalized email request, validates the caller and approved sender, applies template and recipient rules, transforms the body and attachments into the Graph sendMail structure, and invokes Microsoft Graph. The workflow records a correlation ID, limits sensitive logging, and retries eligible transient failures without resending completed requests.
Martini capabilities used
- APIs
- API consumption
- data mapping
- validation
- business rules
- error handling
Pattern 4: Process selected mailbox changes near real time
When to use this pattern
Use this pattern when selected Outlook Messages or Events should trigger downstream action quickly, while maintaining a reliable recovery path for expired subscriptions, duplicate notifications, or missed changes.
Integration direction
Example Mapping
| Microsoft Outlook Field | Canonical Field | Target Field |
|---|---|---|
| subscription.resource | notificationResource | sourceResource |
| resourceData.id | sourceObjectId | external_reference |
| message.subject | requestTitle | short_description |
| message.body.content | requestDetails | description |
Martini implementation pattern
A Martini API receives and validates the Graph notification, then retrieves the authoritative Message or Event rather than trusting the notification payload. The workflow filters and maps the resource, creates or updates the ServiceNow item idempotently, and schedules subscription renewal and periodic delta reconciliation. Duplicate signals and Graph 429 responses are handled through deduplication and bounded retry logic.
Martini capabilities used
- API exposure
- webhook consumption
- workflows
- API consumption
- data mapping
- idempotency
- error handling
Applications commonly integrated with Microsoft Outlook
Microsoft Outlook can be integrated with named enterprise applications to synchronize communication, scheduling, workflow notifications, and inbound requests. The exact direction and object mappings depend on tenant permissions and business rules.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize Outlook messages, contacts, and calendar events with Salesforce activities and contact records. | Microsoft Outlook → Martini → Salesforce | A Martini workflow retrieves selected Messages, Contacts, or Events through Microsoft Graph, normalizes content and identifiers, applies filtering and duplicate checks, and writes activities or contact updates to Salesforce. A reverse workflow can create Outlook meetings or email actions from approved Salesforce events. |
| ServiceNow | Create incidents, cases, or tasks from monitored Outlook messages and send workflow notifications through Outlook. | Microsoft Outlook → Martini → ServiceNow | A scheduled or notification-driven Martini workflow retrieves the current Message, validates mailbox and routing rules, maps subject and body content to ServiceNow fields, and stores the source message ID for idempotent updates. ServiceNow status changes can invoke Microsoft Graph mail operations for notifications. |
| Jira | Convert selected email requests into Jira issues and send issue assignment or status notifications by email. | Microsoft Outlook → Martini → Jira | Martini receives a change notification or polls a configured Mail folder, parses the Message, applies sender and subject rules, creates or updates a Jira issue, and records the Graph message ID and Jira issue key to prevent duplicate creation. |
| Zendesk | Turn support emails into Zendesk tickets and coordinate ticket responses or notifications with Outlook mailboxes. | Microsoft Outlook → Martini → Zendesk | A Martini workflow retrieves inbound Messages and Attachments, converts HTML or quoted content according to policy, maps the email to Zendesk ticket fields, and routes failures for retry or review. Outbound ticket notifications use Microsoft Graph sendMail with controlled sender permissions. |
| NetSuite | Deliver transaction, approval, and exception notifications through Outlook and associate communication with business processes. | NetSuite → Martini → Microsoft Outlook | Martini accepts approved NetSuite events or scheduled data, applies recipient and template rules, constructs a Graph-compatible message with optional attachments, and calls Microsoft Graph sendMail. Responses and transient failures are logged with bounded retries. |
| Workday | Deliver HR workflow notifications, approval requests, and calendar-related communications through Outlook. | Workday → Martini → Microsoft Outlook | A Martini workflow receives or retrieves approved Workday data, validates recipients and data-protection rules, transforms the payload into an Outlook Message, and sends it through Microsoft Graph using application or delegated permissions appropriate to the process. |
| Microsoft Dynamics 365 | Synchronize Outlook email, contacts, appointments, and tasks with Dynamics 365 business records. | Microsoft Outlook → Martini → Microsoft Dynamics 365 | Martini uses Graph delta queries or scheduled retrieval for selected Outlook resources, maps stable IDs and timestamps to Dynamics 365 objects, applies ownership and conflict rules, and writes changes idempotently. Approved Dynamics events can drive outbound Outlook messages or calendar updates. |
| Slack | Publish selected Outlook calendar or mail notifications to Slack channels and route workflow alerts to users. | Microsoft Outlook → Martini → Slack | Martini receives a Graph notification or scheduled result, filters sensitive content, formats a concise Slack message, and calls the Slack API. Retry handling and content redaction prevent transient failures or confidential email bodies from being broadly published. |
How to build a Microsoft Outlook integration in Martini
Objective
Configure Microsoft Graph access for the required tenant, mailbox, or user scope without embedding secrets in workflow logic.
Instructions in Martini
- Choose delegated permissions or application permissions based on the operating model
- Configure Microsoft Entra ID OAuth 2.0 client and tenant values securely
- Request only the Graph scopes required by the workflow
- Store client secrets, tokens, and environment-specific endpoints using Martini secrets and configuration
Objective
Select an event-driven or scheduled entry point that matches the reliability and latency requirements of the Outlook process.
Instructions in Martini
- Use a Martini API or webhook workflow for selected Microsoft Graph change notifications
- Use a scheduler for polling, delta synchronization, subscription renewal, or reconciliation
- Define the mailbox, folder, calendar, or resource scope explicitly
- Treat notifications as signals to retrieve current Outlook state
Objective
Call the appropriate Microsoft Graph resource and collect complete, current data for processing.
Instructions in Martini
- Call the Messages, Mail folders, Events, Calendars, Contacts, Users, or Attachments endpoint
- Follow @odata.nextLink for paginated collections
- Use delta links for applicable incremental synchronization
- Use batching or attachment upload sessions only where the resource scenario supports them
Objective
Coordinate validation, enrichment, routing, target writes, and state management in a maintainable Martini workflow.
Instructions in Martini
- Correlate the Outlook tenant, resource, and workflow execution
- Retrieve related resources such as Attachments or mailbox folders when required
- Route records according to mailbox, sender, folder, event, or business rules
- Persist delta links, source identifiers, and processing outcomes
Objective
Convert Microsoft Graph JSON and content conventions into a stable canonical or target-system model.
Instructions in Martini
- Map Graph IDs, timestamps, recipients, attendees, body content, and status fields
- Normalize HTML, plain text, line breaks, character encoding, and time zones
- Map Attachments with content type, file name, size, and storage policy
- Preserve source identifiers needed for idempotent updates
Objective
Protect data quality and enforce operational, privacy, and authorization decisions before downstream writes.
Instructions in Martini
- Validate required fields, sender or mailbox scope, and recipient authorization
- Define conflict behavior for Events, Calendars, and bidirectional synchronization
- Apply filtering, retention, redaction, and sensitive-content rules
- Reject malformed notifications and unexpected resource paths
Common Microsoft Outlook data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Messages | Synchronize email activity, send outbound mail, route inbound requests, and process sender, recipient, body, category, flag, importance, and timestamp data. | Salesforce, ServiceNow, Jira, Zendesk, Slack, Microsoft Dynamics 365 | Martini retrieves or receives notification signals for Messages, normalizes HTML or text content, maps stable IDs, processes Attachments, and applies duplicate, privacy, and routing rules. |
| Mail folders | Scope mailbox processing to Inbox, Drafts, Sent Items, Deleted Items, or custom folders. | Salesforce, ServiceNow, Jira, Zendesk, data stores | Martini stores the selected folder identifiers, applies folder-specific workflows, follows pagination or delta links, and uses controlled reconciliation for missed changes. |
| Events | Synchronize appointments, meetings, attendees, recurrence, locations, reminders, and online meeting details. | Microsoft Dynamics 365, Salesforce, workforce scheduling applications, Slack | Martini maps time zones, recurrence, organizer, attendee, cancellation, and ownership data, then applies conflict and idempotency rules. |
| Calendars | Identify calendar containers and query event collections for synchronization and scheduling workflows. | Microsoft Dynamics 365, Salesforce, workforce scheduling applications | Martini resolves calendar ownership and identifiers, calls calendar and calendar-view endpoints, and stores synchronization state for incremental processing. |
| Contacts | Synchronize personal Outlook contact information with enterprise contact or customer data. | Salesforce, Microsoft Dynamics 365, customer applications | Martini maps names, addresses, phone numbers, email addresses, and Graph IDs, applying matching and update rules before downstream writes. |
| Attachments | Transfer files, attached Outlook items, and reference attachments with Messages or Events. | Salesforce, ServiceNow, Zendesk, document repositories, storage services | Martini handles metadata and content, supports large-file upload-session patterns where needed, and applies size, malware, retention, and content-type policies. |
Authentication and security considerations
Microsoft Entra ID and OAuth 2.0
Microsoft Graph uses Microsoft Entra ID OAuth 2.0. Use delegated permissions when a workflow acts for a signed-in user and application permissions for service-to-service processing. Client credentials are common for daemon workflows, while authorization code flow supports interactive authorization.
Least privilege and tenant consent
Request only the Outlook permissions required by each workflow, such as Mail.Read, Mail.ReadWrite, Mail.Send, Calendars.Read, Calendars.ReadWrite, Contacts.Read, or Contacts.ReadWrite. Application permissions commonly require tenant administrator consent.
Secrets and notification endpoints
- Protect client secrets, access tokens, tenant identifiers, and synchronization state with secure Martini configuration.
- Validate Microsoft Graph notification requests, client state, resource paths, and validation challenges.
- Limit logs and error payloads because message bodies, attachments, and calendar data may be confidential or regulated.
Operational considerations for Microsoft Outlook integrations
Throttling, pagination, and retries
Microsoft Graph can return HTTP 429 responses with retry information and can also experience transient 5xx or network failures. Workflows should honor Retry-After, use bounded backoff, and avoid aggressive polling. Collection endpoints may return @odata.nextLink and must be paged deliberately.
Incremental synchronization
Use delta queries where the resource and scenario support them. Store delta links securely, process deletions as well as additions and changes, and restart from a controlled baseline when synchronization state becomes invalid.
Notifications and idempotency
Change notifications can be duplicated, delayed, or missed, and subscriptions expire. Renew subscriptions before expiration, retrieve authoritative resource state after notification, use stable source identifiers for idempotency, and schedule reconciliation.
Content and schema behavior
Define policies for HTML bodies, quoted replies, signatures, inline images, attachment size and retention, time zones, recurring Events, cancellations, and attendee changes. Tolerate additive Graph fields, pin documented API versions where appropriate, and test permission and response changes in a non-production tenant.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini coordinates Microsoft Graph calls, notification handling, delta synchronization, subscription renewal, target writes, and reconciliation in workflows rather than scattering logic across scripts.
Reusable integration logic
Reusable APIs, mappings, validation rules, and error paths can support multiple Outlook mailboxes, folders, applications, and environments while keeping tenant-specific configuration separate from implementation.
Reliable data movement
- Handle pagination, throttling, retries, duplicate notifications, idempotency, and partial failures consistently.
- Transform Graph JSON, email content, calendar values, and Attachments into target-specific schemas.
- Expose a controlled API façade for internal applications that need normalized Outlook operations.
Operational visibility
Workflow logs, controlled error handling, and environment configuration provide a maintainable operational model compared with isolated point-to-point scripts.
Frequently asked questions
Microsoft Outlook can be integrated through Microsoft Graph REST APIs for Messages, Mail folders, Events, Calendars, Contacts, Users, mailbox settings, and Attachments. Selected resources also support Microsoft Graph change notifications and applicable delta queries for incremental synchronization. Exchange Web Services is a legacy SOAP option rather than the recommended approach for new Microsoft 365 integrations.
Yes. Martini can consume Microsoft Graph REST APIs, authenticate through Microsoft Entra ID OAuth 2.0, expose an API for selected Microsoft Graph change notifications, and orchestrate scheduled synchronization, delta processing, mapping, business rules, retries, and downstream writes.
No. A dedicated Microsoft Outlook connector is not required or documented in the supplied Martini materials. Martini can use Microsoft Outlook's native Microsoft Graph REST APIs, supported change notifications, delta queries, attachment endpoints, and OAuth 2.0 authentication.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Microsoft Outlook. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Microsoft, cloud infrastructure, or other third-party systems depending on licensing, API usage, and deployment model.
Microsoft Graph REST APIs should be the primary method for new Outlook integrations. Use change notifications for selected near-real-time scenarios, delta queries for incremental synchronization, JSON batching where appropriate, and attachment APIs for file handling. Exchange Web Services is a legacy SOAP-based option and should not be the default for new Microsoft 365 work.
No. Microsoft Graph change notifications are available for selected Outlook resources and scenarios, not as a universal event stream for every operation. Subscriptions have expiration requirements, so implementations should include validation, renewal, duplicate handling, resource re-fetching, and scheduled reconciliation.
Martini can perform an initial load, store Microsoft Graph next or delta links, and process later additions, changes, and deletions for applicable resources. Change notifications can accelerate detection, while scheduled delta or baseline reconciliation provides recovery from missed, delayed, duplicated, or failed notifications.
Martini maps Microsoft Graph JSON into canonical and target schemas, applies validation and business rules, and records stable identifiers such as Graph resource IDs or Internet message IDs. Workflows can honor Graph Retry-After values for HTTP 429 responses, use bounded retries for transient failures, and make downstream writes idempotent. Martini can also expose an API façade that presents normalized Outlook operations to internal applications.
Related Martini documentation
Connect Microsoft Outlook with Martini
Use Microsoft Graph, scheduled workflows, change notifications, and reusable Martini integration logic to connect Outlook mail and calendar data with enterprise applications.