.png)
Atlassian Statuspage Integration Guide
Connect Atlassian Statuspage with enterprise systems through its REST API, selected webhook notifications, and Martini workflows.
Atlassian Statuspage integration options at a glance
Atlassian Statuspage provides a documented REST API for managing pages, components, incidents, incident updates, scheduled maintenances, subscribers, and related configuration. It also supports webhook-style notifications for selected status and incident events, although coverage depends on the event type and account configuration. Statuspage uses page API keys for REST requests, typically supplied in the Authorization header. Martini can consume these APIs, receive supported webhook notifications through an exposed API, schedule reconciliations, map operational data, and apply validation, correlation, retry, and rate-limit handling. No official GraphQL, SOAP, general-purpose bulk, direct database, or file API was confirmed.
| Integration point | Supported by Atlassian Statuspage? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Manage Pages, Components, Incidents, Incident Updates, Scheduled Maintenances, Subscribers, and related configuration. Retrieve operational content for reconciliation. | Martini can consume the Statuspage REST API from workflows, map payloads, expose reusable internal APIs, and orchestrate scheduled or event-driven synchronization. |
| Webhooks / outbound callbacks | Limited | Receive webhook-style notifications for selected status and incident events. Coverage and payload behavior depend on the event and account configuration. | Martini can expose an API endpoint, validate and normalize incoming notifications, route them to downstream systems, and apply replay or duplicate controls. |
| Authentication | Yes | Authenticate REST requests with a page API key, commonly supplied in the Authorization header, subject to page and account permissions. | Martini can store the API key as a secret and apply it to outbound REST requests without embedding credentials in workflows or mappings. |
| Bulk / async / batch APIs | Not confirmed | No separate general-purpose bulk or asynchronous API was confirmed. Larger synchronizations should use controlled iteration over REST resources. | Martini can process paginated work in bounded batches, persist checkpoints, and handle rate limits and transient failures. |
| File / attachment APIs | Not confirmed | Statuspage is primarily an API for structured status content and incident communication. A general-purpose file or attachment API was not confirmed. | Martini can transmit supported text, structured fields, and links, but should not assume arbitrary file upload support. |
| Database / analytics access | Not confirmed | No direct database, JDBC, or general database-access mechanism was confirmed. Metrics should be obtained through documented API resources where available. | Martini can retrieve documented API data and write normalized results to an approved database or analytics destination. |
| GraphQL APIs | Not confirmed | No official Statuspage GraphQL API was confirmed for new integrations. | Martini should use the documented REST API instead of assuming GraphQL availability. |
| SOAP APIs | No | No official Statuspage SOAP interface was confirmed. | Martini can integrate through the Statuspage REST API and supported webhook mechanisms rather than SOAP. |
How Atlassian Statuspage exposes data and business events
Atlassian Statuspage REST APIs
Statuspage provides a REST API for pages, components, incidents, incident updates, scheduled maintenances, subscribers, and related configuration. API-key authentication and page permissions govern access to these resources.
Martini implementation pattern
Martini workflows call the appropriate Statuspage REST resources, validate responses, map vendor objects to canonical models, apply business rules, and write results to downstream systems or expose them through a reusable Martini API.
Implementation sequence
Statuspage Webhook Notifications
Statuspage supports webhook-style notifications for selected status and incident events. This is limited event coverage rather than a guarantee that every object or API change produces a notification.
Martini implementation pattern
Martini exposes a dedicated API endpoint for supported notifications, validates available authentication or signing information, normalizes the payload, filters duplicates, and routes the event to service-management, collaboration, or incident systems.
Implementation sequence
Scheduled REST Synchronization
Statuspage does not provide a confirmed general-purpose bulk or asynchronous API. Larger reconciliations therefore rely on controlled REST retrieval, pagination, and workflow-level batching.
Martini implementation pattern
A Martini scheduler starts a bounded synchronization workflow that retrieves Pages, Components, Incidents, Scheduled Maintenances, or Subscribers, persists progress, compares state, and updates only changed target objects.
Implementation sequence
Common Atlassian Statuspage integration patterns
Pattern 1: Synchronize service incidents to Statuspage
When to use this pattern
Use this pattern when Jira Service Management, Opsgenie, or PagerDuty incidents should create or update customer-facing Statuspage Incidents only after impact and approval rules are met.
Integration direction
Example Mapping
| Atlassian Statuspage Field | Canonical Field | Target Field |
|---|---|---|
| incident.key | sourceIncidentId | correlationKey |
| incident.summary | incidentTitle | Incident.name |
| incident.impact | impactLevel | Incident.impact |
| incident.description | publicMessage | Incident.message |
Martini implementation pattern
Martini receives or retrieves the source incident, validates customer-facing content and affected services, maps lifecycle and impact values, checks the correlation store before creating an Incident, and updates the existing Statuspage Incident when the source lifecycle changes. Transient API failures are retried; ambiguous timeouts are reconciled before another create operation.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- secrets management
- error handling
Pattern 2: Route Statuspage updates to operations channels
When to use this pattern
Use this pattern when selected Statuspage incident or component notifications must be reflected in Jira Service Management, Slack, Microsoft Teams, or an internal operations dashboard.
Integration direction
Example Mapping
| Atlassian Statuspage Field | Canonical Field | Target Field |
|---|---|---|
| incident_id | statuspageIncidentId | externalIncidentId |
| incident_status | incidentLifecycle | status |
| impact | impactLevel | priority |
| update.message | publicUpdate | description |
Martini implementation pattern
A Martini API receives supported notifications, validates available security information, normalizes the event, applies routing and deduplication rules, and sends the appropriate representation to each target. Unsupported or malformed events are rejected or quarantined without causing repeated downstream messages.
Martini capabilities used
- API exposure
- workflow orchestration
- data mapping
- conditional routing
- error handling
Pattern 3: Synchronize component status from monitoring
When to use this pattern
Use this pattern when Datadog, New Relic, or another operational source should influence Statuspage Components without publishing every transient monitoring fluctuation.
Integration direction
Example Mapping
| Atlassian Statuspage Field | Canonical Field | Target Field |
|---|---|---|
| monitor.alertState | serviceState | Component.status |
| monitor.serviceName | serviceIdentifier | Component.name |
| monitor.severity | impactLevel | Component.statusRule |
| monitor.observedAt | observationTime | audit.timestamp |
Martini implementation pattern
Martini retrieves or receives monitoring signals, resolves the source service to a Statuspage Component, applies thresholds and state-transition rules, compares the current component state, and performs an idempotent REST update only when the defined policy is met. The workflow records failed updates for reconciliation.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- business rules
- idempotency
- retry handling
Pattern 4: Publish approved scheduled maintenance
When to use this pattern
Use this pattern when an approved Jira Software or change-management item should become a public Statuspage Scheduled Maintenance event.
Integration direction
Example Mapping
| Atlassian Statuspage Field | Canonical Field | Target Field |
|---|---|---|
| issue.key | changeId | correlationKey |
| issue.summary | maintenanceName | ScheduledMaintenance.name |
| plannedStart | startTimeUtc | ScheduledMaintenance.start |
| plannedEnd | endTimeUtc | ScheduledMaintenance.end |
Martini implementation pattern
A Martini API accepts an approved change request, validates the maintenance window and affected components, converts timestamps to UTC, maps the payload, calls the Statuspage REST API, and returns or stores the resulting identifier. Validation failures are rejected before publication and transient failures follow bounded retries.
Martini capabilities used
- API exposure
- workflows
- validation
- data transformation
- business rules
- error handling
Applications commonly integrated with Atlassian Statuspage
Statuspage is commonly positioned alongside incident management, monitoring, collaboration, and change-management applications. The relationships below are architecture patterns rather than evidence that each product has a first-party Statuspage connector. Martini can provide the orchestration layer using APIs, supported notifications, validation, and reusable workflows.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Jira Service Management | Synchronize major incidents, service-impacting changes, and public incident communications between the service desk and Statuspage. | Jira Service Management → Martini → Atlassian Statuspage | Receive a qualifying incident from Jira Service Management, validate impact and affected components, create or update the Statuspage Incident, and store the source-to-Statuspage correlation. Selected Statuspage notifications can be normalized and sent back to the service desk. |
| Jira Software | Associate releases, deployments, and planned changes with scheduled maintenance or service-status communications. | Jira Software → Martini → Atlassian Statuspage | Expose a Martini API for approved release or change requests, map timing and affected components to a Scheduled Maintenance payload, publish it through the Statuspage REST API, and return the resulting identifier. |
| Slack | Distribute incidents, component changes, and maintenance announcements to operational and stakeholder channels. | Atlassian Statuspage → Martini → Slack | Receive supported Statuspage notifications, normalize incident or component data, apply routing rules, and send formatted messages to selected Slack channels through the configured Slack endpoint. |
| Microsoft Teams | Publish customer-impacting incidents and maintenance notices to engineering, support, and stakeholder channels. | Atlassian Statuspage → Martini → Microsoft Teams | Use a Martini webhook workflow to validate and transform Statuspage notifications, filter duplicate or low-priority events, and deliver structured Teams notifications. |
| Opsgenie | Coordinate incident response with public status communication when an alert reaches a defined service-impact threshold. | Opsgenie → Martini → Atlassian Statuspage | Consume qualifying Opsgenie events, map severity and service information to Statuspage impact and component values, create or update an Incident, and retain correlation data for lifecycle updates. |
| PagerDuty | Publish customer-facing status updates for selected PagerDuty incidents without exposing every internal alert publicly. | PagerDuty → Martini → Atlassian Statuspage | Receive PagerDuty event data, apply severity, service, approval, and deduplication rules, then call the Statuspage REST API for approved incident operations. |
| Datadog | Use service-health and monitoring signals to inform component-status or incident workflows. | Datadog → Martini → Atlassian Statuspage | Receive or retrieve selected Datadog alerts, apply thresholds and state-transition rules, compare the current Statuspage Component state, and update it only when a meaningful transition occurs. |
| New Relic | Correlate application-performance alerts with Statuspage component or incident communications. | New Relic → Martini → Atlassian Statuspage | Normalize New Relic alert data in a Martini workflow, map services and severity to Statuspage objects, enforce public-content governance, and retry transient Statuspage failures safely. |
How to build a Atlassian Statuspage integration in Martini
Objective
Configure authenticated access to the Statuspage REST API while keeping the page API key outside workflow logic.
Instructions in Martini
- Create a Martini secret for the Statuspage API key
- Configure the Authorization header for outbound REST requests
- Confirm the key has the required page permissions
- Use separate credentials for development and production
Objective
Select an event, API request, or schedule that matches the synchronization requirement and the limited coverage of Statuspage notifications.
Instructions in Martini
- Use a Martini API for supported inbound notifications or commands
- Use a scheduler for reconciliation and polling
- Use source-system events for incident or maintenance publication
- Avoid assuming every Statuspage change generates a webhook
Objective
Obtain the current Statuspage resource or normalize the received notification before applying business logic.
Instructions in Martini
- Call the relevant REST resource for Pages, Components, Incidents, or Scheduled Maintenances
- Follow documented pagination for list resources
- Validate webhook payloads and identify correlation keys
- Persist checkpoints for larger synchronizations
Objective
Coordinate validation, enrichment, target calls, and lifecycle handling in a maintainable Martini workflow.
Instructions in Martini
- Separate incident, component, and maintenance paths where rules differ
- Resolve source objects to Statuspage identifiers
- Apply approval and public-content governance
- Keep reusable mappings and target operations modular
Objective
Convert Statuspage fields and external operational data into a stable canonical model before writing to another system.
Instructions in Martini
- Map incident lifecycle and impact values explicitly
- Normalize timestamps to UTC while retaining source time-zone context
- Transform component and service identifiers
- Handle optional fields and schema additions defensively
Objective
Prevent inappropriate public updates, duplicate incidents, and noisy component transitions.
Instructions in Martini
- Require defined severity or approval thresholds
- Check correlation data before creating an Incident
- Compare current and desired Component states
- Reject invalid maintenance windows and sensitive public content
Common Atlassian Statuspage data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Pages | Represent public or private status pages managed by an organization. | Jira Service Management, internal service catalogs, operational dashboards | Martini retrieves or updates page information through authenticated REST workflows and applies page-level routing and permission rules. |
| Components | Represent services or functional areas with states such as operational, degraded performance, partial outage, or major outage. | Datadog, New Relic, PagerDuty, operations dashboards | Martini maps monitoring or service-management states to component values, applies thresholds, and performs idempotent updates. |
| Incidents | Communicate service-impacting events, their impact, status, and lifecycle. | Jira Service Management, Opsgenie, PagerDuty, Slack, Microsoft Teams | Martini creates and updates incidents through REST calls, stores correlation identifiers, validates public content, and retries transient failures. |
| Incident Updates | Publish progress messages and lifecycle changes for an Incident. | Service desks, collaboration channels, incident-management platforms | Martini transforms internal updates into Statuspage content and normalizes selected Statuspage notifications for downstream systems. |
| Scheduled Maintenances | Communicate planned maintenance windows, affected components, timing, and expected impact. | Jira Software, Jira Service Management, change-management platforms | Martini validates time ranges, normalizes timestamps to UTC, maps affected components, and publishes approved maintenance payloads. |
| Subscribers | Represent people or endpoints subscribed to status notifications through supported channels. | Customer communication systems, service desks, notification platforms | Martini can retrieve or synchronize subscriber data through documented API resources while applying permission, privacy, and pagination controls. |
Authentication and security considerations
API-key authentication
Statuspage REST requests use a page API key, commonly supplied in the Authorization header. Access depends on the page and account permissions associated with the key.
Martini protection
- Store the API key in Martini Secrets Management rather than workflow code or mappings.
- Use separate credentials and configuration for each environment.
- Restrict exposed Martini API methods, HTTP methods, and content types.
- Validate available webhook authentication, signing, or secret values before processing notifications.
- Log correlation identifiers and processing outcomes without exposing credentials or sensitive public-content data.
Operational considerations for Atlassian Statuspage integrations
Reliability and API behavior
- Respect Statuspage rate limits, HTTP 429 responses, and applicable rate-limit headers.
- Use bounded exponential backoff for transient failures and separate urgent incident operations from reconciliation jobs.
- Follow documented pagination and persist checkpoints for large lists.
- Use correlation keys and idempotent state comparisons to prevent duplicate Incidents and repeated Component updates.
- Normalize maintenance and incident timestamps to UTC and validate start and end times.
Governance and change management
- Require approval and content validation before publishing customer-visible incident or maintenance information.
- Use versioned mappings to tolerate optional fields, enum additions, and changes to incident update structures.
- Test public, private, and applicable enterprise page configurations separately.
- Persist failed payloads and correlation data so operators can replay failed synchronizations safely.
Why use Martini instead of scripts or point-to-point integrations?
More than a point-to-point script
Martini provides a governed workflow layer around the Statuspage REST API and selected notifications. It separates authentication, mappings, business rules, retries, correlation, and target-system operations so the integration can evolve without duplicating logic across scripts.
Operational control
- Use reusable workflows and APIs for incident, component, and maintenance processes.
- Combine real-time notifications with scheduled reconciliation when event coverage is limited.
- Apply consistent validation, rate-limit handling, idempotency, and error management.
- Expose a normalized internal API while keeping Statuspage credentials and vendor-specific payloads controlled.
- Monitor workflow outcomes and troubleshoot failures through centralized integration behavior rather than disconnected scripts.
Frequently asked questions
Atlassian Statuspage can be integrated through its REST API, which manages Pages, Components, Incidents, Incident Updates, Scheduled Maintenances, Subscribers, and related resources. It also supports webhook-style notifications for selected status and incident events. API-key authentication is used for REST requests, while Martini can orchestrate workflows, scheduled synchronization, mappings, validation, and downstream updates.
Yes. Martini can consume the Atlassian Statuspage REST API, receive supported webhook notifications through an exposed API, schedule reconciliation workflows, and map Statuspage objects to systems such as Jira Service Management, Slack, Microsoft Teams, monitoring platforms, and incident-management tools.
No. A dedicated Atlassian Statuspage connector is not required. Martini can use Statuspage's confirmed native integration mechanisms, primarily its REST API, page API-key authentication, and selected webhook-style notifications.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Atlassian Statuspage. The integration uses the provisioned capacity of the Martini environment. Separate costs may apply from Atlassian, cloud infrastructure, or other third-party systems depending on subscriptions, usage, and deployment model.
The primary method is the documented Statuspage REST API, supplemented by supported webhook-style notifications for selected events. No official GraphQL or SOAP API was confirmed, and no general-purpose bulk, direct database, or file API should be assumed.
No. Statuspage supports webhook-style notifications for selected status and incident events, but coverage should not be generalized to every object or API change. The supported event types, payload behavior, security options, and retry behavior should be confirmed for the specific account configuration.
Use a canonical mapping layer for lifecycle, impact, component, and timestamp values, and apply explicit business rules before publishing customer-visible content. Store source-to-Statuspage correlation identifiers, check them before creating incidents, follow pagination, respect rate limits, and retry only transient failures with bounded backoff.
Yes. Martini can expose a controlled REST API that hides Statuspage-specific authentication and payload details from internal callers. The façade can validate requests, apply approval and public-content rules, invoke Statuspage workflows, and return normalized responses while keeping the page API key in Martini secrets.
Related Martini documentation
API Workflows
Workflows
Connect Atlassian Statuspage with Martini
Use Martini to build governed Statuspage integrations across incident management, monitoring, collaboration, and change-management systems.