.png)
Azure DevOps Integration Guide
Connect Azure DevOps Projects, Work Items, Repositories, Pull Requests, and Pipelines with enterprise systems through REST APIs, Service Hooks, batch operations, and Analytics OData.
Azure DevOps integration options at a glance
Azure DevOps provides broad REST APIs for Projects, Work Items, Git Repositories, Pull Requests, Pipelines, Builds, Releases, Tests, Artifacts, and Service Hooks. Service Hooks can send webhook notifications for selected events, while batch operations support efficient retrieval for resources such as Work Items. Pipeline and test operations commonly run asynchronously and require polling or event-based status handling. Azure DevOps also exposes Analytics OData for reporting, separate from transactional APIs, and supports Microsoft Entra tokens, OAuth 2.0, and scoped personal access tokens. Martini can consume these endpoints, receive Service Hook notifications, map JSON, schedule synchronization workflows, and expose controlled APIs.
| Integration point | Supported by Azure DevOps? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Manage Projects, Work Items, Git Repositories, Pull Requests, Pipelines, Builds, Releases, Tests, Artifacts, identities, and Service Hooks. | Martini can consume Azure DevOps REST endpoints, map JSON payloads, apply business rules, and expose REST APIs for downstream systems. |
| Webhooks / outbound callbacks | Yes | Service Hooks send notifications for selected Work Item, repository, build, pipeline, and other supported events. | Martini can expose a REST API endpoint to receive notifications, retrieve the authoritative resource, and route the event through a workflow. |
| Bulk / batch / asynchronous APIs | Limited | Batch operations exist for selected resources, including Work Items; Pipelines, Builds, Releases, and Tests commonly execute asynchronously. | Martini can use batch endpoints, persist operation or run identifiers, poll with controlled intervals, and process applicable completion events. |
| File and attachment APIs | Yes | Upload and associate attachments with Work Items; repository files and package artifacts use their respective Azure DevOps APIs. | Martini can transfer file content and metadata, map attachment relationships, and apply duplicate and content-type handling. |
| Analytics OData | Limited | Query Azure DevOps Analytics for reporting and analytical datasets separate from transactional REST APIs. | Martini can consume Analytics OData, transform results into reporting schemas, and write or expose them to downstream applications. |
| Authentication | Yes | Use Microsoft Entra access tokens, Microsoft Entra OAuth 2.0, or scoped personal access tokens subject to current Microsoft guidance and permissions. | Martini can store credentials in secure configuration, call authenticated endpoints, and apply environment-specific authorization settings. |
| GraphQL APIs | Not confirmed | No general-purpose public Azure DevOps GraphQL API was confirmed; documented integration surfaces are REST and Analytics OData. | Martini should use the confirmed REST or OData HTTP interfaces rather than assume GraphQL support. |
| SOAP APIs | No | Current Azure DevOps integration documentation centers on REST, Service Hooks, client libraries, and Analytics OData. | Martini can consume SOAP services from other systems in the surrounding integration, but Azure DevOps should be accessed through its confirmed interfaces. |
How Azure DevOps exposes data and business events
Azure DevOps REST APIs
Azure DevOps REST APIs provide the broadest documented integration surface across Projects, Work Items, Git, Pull Requests, Pipelines, Builds, Releases, Tests, Artifacts, identities, and Service Hooks. API versions are explicit and vary by resource area.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates to the selected Azure DevOps REST endpoint, retrieves or submits JSON, applies validation and transformation, and writes the result to the target system or exposes it through a Martini API.
Implementation sequence
Azure DevOps Service Hooks
Azure DevOps Service Hooks can send webhook notifications for selected events. Coverage is event-specific and varies by Azure DevOps service, so notifications should not be treated as a universal stream of every operation.
Martini implementation pattern
Martini implementation pattern: expose a controlled REST API endpoint for the Service Hook, validate and acknowledge the notification, retrieve the authoritative resource through REST, and process the event asynchronously when appropriate.
Implementation sequence
Azure DevOps batch and asynchronous APIs
Selected Azure DevOps services provide batch operations, including Work Items. Pipeline, Build, Release, and Test operations commonly start asynchronously and require a later status check or applicable event.
Martini implementation pattern
Martini implementation pattern: a workflow groups eligible requests, calls a batch or start-operation endpoint, persists the returned identifiers, and polls or consumes a supported event with bounded retries and backoff.
Implementation sequence
Azure DevOps Analytics OData
Azure DevOps Analytics exposes OData for reporting and analytical queries. It is separate from transactional REST APIs and has distinct permissions, entities, retention, and availability considerations.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow queries the required Analytics OData data, handles continuation or result limits, maps the analytical entities to a reporting schema, and stores or exposes the output.
Implementation sequence
Common Azure DevOps integration patterns
Pattern 1: Synchronize Work Items with ServiceNow
When to use this pattern
Use this pattern when Azure DevOps Bugs, Tasks, User Stories, or custom Work Items must be reflected in ServiceNow incidents, changes, or service records. Service Hooks provide low-latency notifications for supported events, while scheduled reconciliation covers missed or unsupported changes.
Integration direction
Example Mapping
| Azure DevOps Field | Canonical Field | Target Field |
|---|---|---|
| id | sourceWorkItemId | correlation_id |
| fields.System.Title | workItemTitle | short_description |
| fields.System.State | workItemStatus | state |
| fields.System.AreaPath | areaPath | assignment_group |
Martini implementation pattern
Martini receives the Service Hook, retrieves the full Work Item, maps standard and custom fields, applies state and identity rules, and creates or updates ServiceNow using a stored correlation key. Retries, duplicate delivery checks, and scheduled reconciliation protect against transient failures and incomplete event coverage.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
- scheduled synchronization
Pattern 2: Create Azure DevOps work from Salesforce
When to use this pattern
Use this pattern when a Salesforce Case, Account, Opportunity, or delivery request needs a corresponding Azure DevOps Work Item and customer-facing status updates. The flow supports controlled creation and subsequent synchronization of selected fields.
Integration direction
Example Mapping
| Azure DevOps Field | Canonical Field | Target Field |
|---|---|---|
| Case.Id | customerCaseId | Custom.CustomerCaseId |
| Case.Subject | workItemTitle | System.Title |
| Case.Priority | priority | Microsoft.VSTS.Common.Priority |
| Case.Status | customerStatus | Custom.CustomerStatus |
Martini implementation pattern
A Martini workflow receives or retrieves the Salesforce request, validates required project and Work Item type values, creates or updates the Azure DevOps item, and returns the Azure DevOps ID. A reverse workflow retrieves status changes and applies allowed transitions back to Salesforce, with deterministic upsert and retry handling.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- business rules
- error handling
Pattern 3: Distribute Pipeline status
When to use this pattern
Use this pattern when delivery teams need Azure DevOps Pipeline or Build status in Microsoft Teams, Slack, ServiceNow, or an internal operations API. Service Hooks can be used for supported events, with polling as a fallback for asynchronous operations.
Integration direction
Example Mapping
| Azure DevOps Field | Canonical Field | Target Field |
|---|---|---|
| pipeline.id | pipelineId | external_pipeline_id |
| run.name | runName | message_title |
| run.state | runState | status |
| run.result | runResult | message_body |
Martini implementation pattern
Martini receives a supported event or queries run status, normalizes state and result values, enriches the notification with project and repository context, and routes it by project or environment. The workflow persists run IDs, suppresses duplicate notifications, and retries downstream delivery with bounded backoff.
Martini capabilities used
- API consumption
- webhook receiving
- workflow orchestration
- data transformation
- conditional routing
- error handling
Pattern 4: Build an incremental delivery report
When to use this pattern
Use this pattern when an organization needs a consolidated view of Work Items, Pull Requests, commits, Pipeline runs, or Analytics data without repeatedly scanning every project. Resource-specific timestamps, WIQL, continuation mechanisms, and scheduled reconciliation are combined.
Integration direction
Example Mapping
| Azure DevOps Field | Canonical Field | Target Field |
|---|---|---|
| Work Item ID | workItemId | azure_work_item_id |
| System.ChangedDate | changedAt | changed_at |
| Pull Request status | pullRequestStatus | pull_request_status |
| Pipeline result | pipelineResult | pipeline_result |
Martini implementation pattern
A scheduled Martini workflow reads the last checkpoint, queries each Azure DevOps service using its supported incremental strategy, follows continuation information, maps the results into a reporting schema, and upserts them into PostgreSQL. Checkpoints advance only after successful writes, while failed pages remain eligible for retry.
Martini capabilities used
- scheduled workflows
- API consumption
- OData consumption
- pagination handling
- data mapping
- database integration
- checkpointing
Applications commonly integrated with Azure DevOps
Azure DevOps can be connected with adjacent enterprise applications to synchronize engineering work, customer-facing status, delivery events, and reporting data. The exact direction and object scope depend on the APIs and event coverage available in each application.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| ServiceNow | Synchronize Azure DevOps Bugs, User Stories, Tasks, and deployment events with incidents, change requests, and service records. | Azure DevOps → Martini → ServiceNow | Martini receives selected Service Hooks, retrieves the authoritative Work Item, maps fields and correlation identifiers, and creates or updates the corresponding ServiceNow record with retry and duplicate handling. |
| Salesforce | Link customer Cases, Accounts, or Opportunities to engineering Work Items and return delivery status to customer-facing teams. | Salesforce → Martini → Azure DevOps | A Martini workflow consumes Salesforce events or scheduled queries, validates the request, creates or updates Azure DevOps Work Items, and returns Azure DevOps identifiers and status to Salesforce. |
| Jira | Coordinate work across teams using Jira for planning and Azure DevOps for source control, delivery, or selected engineering work. | Jira → Martini → Azure DevOps | Martini synchronizes selected issue and Work Item fields, applies field and status rules, stores cross-system identifiers, and uses scheduled reconciliation alongside event processing where available. |
| Microsoft Teams | Publish pipeline, pull request, or Work Item notifications to engineering and delivery channels. | Azure DevOps → Martini → Microsoft Teams | Martini receives applicable Service Hook events, normalizes the event content, applies routing rules, and calls the selected Microsoft Teams endpoint for channel delivery. |
| Slack | Send build, deployment, pull request, and Work Item notifications to operational or engineering channels. | Azure DevOps → Martini → Slack | A Martini API receives Azure DevOps notifications, filters events by project or resource type, transforms the message, and invokes the Slack API with controlled retries. |
| Power BI | Combine Azure DevOps Analytics data with delivery, resource, or business data for reporting. | Azure DevOps → Martini → Power BI | Martini queries Analytics OData or transactional APIs on a schedule, maps the result to a reporting model, and exposes or writes the transformed dataset for Power BI consumption. |
| GitHub | Coordinate repositories, pull requests, commits, or CI/CD workflows across GitHub and Azure DevOps. | GitHub → Martini → Azure DevOps | Martini receives or polls source-control events, maps repository and pull-request identifiers, applies synchronization rules, and calls the relevant Azure DevOps REST endpoints. |
| NetSuite | Associate delivery Work Items or project milestones with customer, project, or financial records. | NetSuite → Martini → Azure DevOps | Martini receives a NetSuite project or milestone request, creates or updates an Azure DevOps Work Item, stores correlation data, and sends completion or status updates back to NetSuite. |
How to build a Azure DevOps integration in Martini
Objective
Establish authenticated access to the required Azure DevOps organization, project, and resource areas using the least-privileged practical identity.
Instructions in Martini
- Choose Microsoft Entra OAuth, a Microsoft Entra access token, or a narrowly scoped PAT based on the deployment context.
- Store credentials and environment-specific values in secure Martini configuration.
- Confirm permissions for Work Items, Code, Build, Release, Project, Team, or Service Hooks as required.
Objective
Select an event-driven, scheduled, or API-led entry point based on the required latency and Azure DevOps event coverage.
Instructions in Martini
- Expose a Martini REST API for supported Service Hook notifications.
- Use a scheduler for reconciliation, reporting, and incremental synchronization.
- Use an API-triggered workflow when another application initiates Azure DevOps work.
Objective
Obtain the authoritative Azure DevOps resource rather than relying only on a notification payload.
Instructions in Martini
- Call the resource-specific REST endpoint using the required API version.
- Use WIQL and follow-up Work Item retrieval where appropriate.
- Follow continuation information and use batch operations when supported.
Objective
Coordinate calls, asynchronous operations, routing, and persistence through a maintainable Martini workflow.
Instructions in Martini
- Separate event receipt from longer-running processing when appropriate.
- Persist resource, operation, and destination identifiers for correlation.
- Poll asynchronous Pipeline, Build, Release, or Test operations with controlled intervals.
Objective
Convert Azure DevOps fields, identities, states, paths, attachments, and timestamps into the target system model.
Instructions in Martini
- Map standard and custom Work Item fields explicitly.
- Avoid using display names as permanent identity keys.
- Preserve source identifiers and API version context in the canonical model.
Objective
Apply validation, project routing, allowed state transitions, duplicate detection, and security rules before writing data.
Instructions in Martini
- Validate required project, repository, Work Item type, and target identifiers.
- Use stable Azure DevOps IDs and destination IDs for idempotent create-or-update logic.
- Handle custom process templates, fields, Area Paths, and Iterations explicitly.
Common Azure DevOps data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Organizations | Top-level containers that own projects, users, policies, and service settings. | ServiceNow, Salesforce, reporting databases, identity platforms | Martini uses organization identifiers as part of routing, authorization, correlation, and multi-organization synchronization rules. |
| Projects | Containers for Boards, Repos, Pipelines, Test Plans, and project configuration. | ServiceNow, Salesforce, Power BI, internal project systems | Martini retrieves project metadata, maps project identifiers and settings, and applies project-specific routing or scope rules. |
| Work Items | Track User Stories, Bugs, Tasks, Features, Epics, and custom work item types. | ServiceNow, Salesforce, Jira, databases, reporting platforms | Martini can query with WIQL, retrieve full fields, create or update items, map custom fields, and track stable Work Item IDs. |
| Repositories | Store source code in Git or Team Foundation Version Control repositories. | GitHub, reporting systems, notification platforms, data warehouses | Martini can retrieve repository metadata and synchronize selected repository, commit, or event information through REST workflows. |
| Pull requests | Represent proposed code changes, reviewers, branches, and policy status. | Jira, Slack, Microsoft Teams, ServiceNow, reporting platforms | Martini maps pull request identifiers, status, reviewers, and repository context, with event-driven or scheduled processing. |
| Pipelines | Define and execute CI/CD workflows with runs, stages, jobs, and artifacts. | ServiceNow, Microsoft Teams, Slack, Power BI, operations APIs | Martini starts or monitors runs, persists asynchronous correlation IDs, polls status when needed, and distributes normalized results. |
Authentication and security considerations
Use scoped, managed credentials
Azure DevOps supports Microsoft Entra access tokens, Microsoft Entra OAuth 2.0, and personal access tokens. New production integrations should evaluate current Microsoft guidance and prefer an identity and permission model appropriate to the deployment.
- Store tokens and secrets in Martini secure configuration rather than workflow definitions.
- Apply least-privilege permissions for the required organization, project, repository, pipeline, and Service Hook resources.
- Use narrow PAT scopes and rotate PATs regularly when they are required.
- Protect Martini API endpoints that receive Service Hook notifications and validate the event source before processing.
Operational considerations for Azure DevOps integrations
Design for Azure DevOps behavior
- Use explicit REST API versions per resource and test upgrades before changing versions globally.
- Respect throttling guidance, response headers, continuation information, and service-specific pagination behavior.
- Use batch operations where supported and limit concurrency for large synchronization jobs.
- Retrieve complete Work Items after WIQL results and account for custom fields, process templates, Area Paths, and Iterations.
- Persist stable identifiers and checkpoints so retries and duplicate Service Hook deliveries are safe.
- Poll asynchronous Pipeline, Build, Release, and Test operations with bounded intervals, or consume an applicable Service Hook event.
- Test attachment size, content type, scanning, and duplicate behavior before synchronizing files.
Why use Martini instead of scripts or point-to-point integrations?
Coordinate more than an API call
Point-to-point scripts often embed credentials, field mappings, retry behavior, and assumptions about one Azure DevOps project or process. Martini provides a governed workflow layer for API consumption, event receipt, scheduling, transformation, validation, routing, and controlled API exposure.
- Reuse integration assets across organizations, projects, Work Item types, and target applications.
- Separate authentication and environment configuration from workflow logic.
- Combine Service Hook notifications with authoritative REST retrieval and scheduled reconciliation.
- Handle pagination, throttling, asynchronous status, retries, correlation, and duplicate delivery consistently.
- Expose a controlled Martini API façade when downstream applications should not depend directly on Azure DevOps details.
Frequently asked questions
Azure DevOps can be integrated through its REST APIs, Service Hooks for selected webhook events, batch operations, asynchronous Pipeline and Build APIs, file and attachment APIs, and Analytics OData. Authentication can use Microsoft Entra tokens, OAuth 2.0, or scoped personal access tokens.
Yes. Martini can consume Azure DevOps REST and Analytics OData endpoints, receive selected Service Hook notifications through a Martini REST API, orchestrate asynchronous operations, transform JSON, and synchronize Azure DevOps data with enterprise applications.
No dedicated Azure DevOps connector is required. Martini can integrate using Azure DevOps REST APIs, Service Hooks, batch or asynchronous endpoints, Analytics OData, and the confirmed Azure DevOps authentication mechanisms.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Azure DevOps. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Microsoft, Azure DevOps, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
REST APIs are the primary integration method because they cover the major Azure DevOps services. Use Service Hooks for supported low-latency events, batch endpoints where available, asynchronous polling for long-running operations, and Analytics OData for reporting rather than transactional updates.
Azure DevOps Service Hooks can send webhook notifications for selected events. Coverage varies by service and event, so a robust design retrieves the current resource through REST and combines event processing with scheduled reconciliation when complete event coverage is required.
Synchronization can use Work Item queries and WIQL, changed dates or revision information, continuation mechanisms, repository and Pull Request identifiers, Pipeline timestamps, and Service Hooks. There is no single incremental-sync protocol for every Azure DevOps service, so the workflow should use a service-specific checkpoint and correlation strategy.
Martini workflows can validate payloads, apply bounded retries and backoff, handle pagination and throttling, persist checkpoints, and route failures for review. Stable organization, project, Work Item, repository, Pull Request, and run identifiers support idempotent processing and duplicate suppression.
Related Martini documentation
Azure DevOps APIs
Workflows
Connect Azure DevOps to your enterprise systems
Use Martini to build maintainable Azure DevOps integrations around REST APIs, Service Hooks, asynchronous operations, Analytics OData, and secure workflow orchestration.