.png)
Grafana Cloud Integration Guide
Connect Grafana Cloud observability data and alerting with enterprise systems through HTTP APIs, Prometheus- and Loki-compatible endpoints, webhook notifications, and Martini workflows.
Grafana Cloud integration options at a glance
Grafana Cloud integrations primarily use Grafana HTTP APIs for dashboards, folders, data sources, alerting, annotations, users, teams, and administration. Prometheus-compatible endpoints support metrics queries and high-volume ingestion, while Loki-compatible APIs support log queries and ingestion. Grafana Alerting can send selected notifications through webhook contact points to a Martini API or webhook-triggered workflow. Martini can also schedule polling and reconciliation workflows, transform dashboard or alert JSON, apply validation and business rules, and route metrics, logs, and alerts to enterprise applications. Authentication may use service account tokens, access policy tokens, or Basic Authentication for selected hosted endpoints.
| Integration point | Supported by Grafana Cloud? | Common use cases | How Martini supports it |
|---|---|---|---|
| Grafana HTTP APIs | Yes | Create and update dashboards, manage folders and data sources, administer alert rules and contact points, add annotations, and synchronize users or teams where permissions allow. | Martini can consume the HTTP APIs from workflows, generate reusable API assets from external definitions where applicable, transform JSON, and handle authentication, validation, retries, and routing. |
| Prometheus-compatible APIs | Yes | Query Grafana Cloud hosted metrics and support high-volume metric ingestion through supported Prometheus-compatible mechanisms such as remote write. | Martini can schedule metric queries, transform query results, apply thresholds, and orchestrate bounded batches. High-volume telemetry forwarding should generally remain with purpose-built collectors. |
| Loki-compatible APIs | Yes | Query logs with LogQL and push structured or unstructured log streams where the Grafana Cloud tenant supports ingestion. | Martini can call Loki endpoints, constrain time windows and labels, transform selected results, and route log-derived conditions to downstream workflows. |
| Webhooks / outbound callbacks | Limited | Grafana Alerting can send configured alert notifications through webhook contact points. This does not provide a universal event stream for all Grafana Cloud object changes. | Martini can expose a REST API or webhook-triggered workflow to validate, deduplicate, normalize, and route alert payloads. |
| Bulk and asynchronous telemetry ingestion | Yes | Metrics and logs support streaming or batched ingestion patterns designed for higher-volume telemetry workloads. | Martini can orchestrate bounded batches, split payloads, apply retry and backoff policies, and track failed chunks, while accounting for throughput and payload limits. |
| Authentication | Yes | Service account tokens and access policy tokens support scoped API access; Basic Authentication is used for selected hosted metrics and logs endpoints. | Martini can store endpoint-specific credentials as environment secrets and apply the required HTTP authentication pattern from workflows. |
| Configured data-source query access | Limited | Grafana Cloud can query configured sources and expose service-specific query APIs, but direct access to Grafana Cloud's internal database is not confirmed. | Martini can call Grafana and source-system APIs or connect independently to an external database when business data resides outside Grafana Cloud. |
| Files and attachments | Not confirmed | Dashboard JSON and configuration can be retrieved through APIs, but a general Grafana Cloud file or attachment API was not confirmed. | Martini can process exported JSON or files exchanged with another storage system, but should not assume Grafana Cloud provides general attachment storage. |
How Grafana Cloud exposes data and business events
Grafana HTTP APIs
Grafana HTTP APIs provide request-based access to dashboards, folders, data sources, alerting resources, annotations, users, teams, and administration functions. The available operations depend on the Grafana Cloud service, API area, and permissions of the calling identity.
Martini implementation pattern
Martini implementation pattern: a workflow invokes the relevant Grafana HTTP endpoint using a service account token or access policy token, validates the response, maps the returned JSON into a canonical model, and writes the result to a target system or a second Grafana environment.
Implementation sequence
Prometheus-compatible metrics APIs
Grafana Cloud hosted metrics provides Prometheus-compatible query and ingestion endpoints. Query operations can retrieve time-series results, while supported ingestion mechanisms are designed for higher-volume telemetry and may use stack-specific endpoints and tenant identifiers.
Martini implementation pattern
Martini implementation pattern: a scheduled or event-driven workflow calls the appropriate metrics endpoint, limits the query window and labels, transforms the result into an operational model, and applies thresholds or routing rules before sending selected results to another application. High-volume forwarding should use bounded batches or purpose-built collectors.
Implementation sequence
Loki-compatible log APIs
Grafana Cloud Logs exposes Loki-compatible APIs for LogQL queries and supported log ingestion. Query scope, retention, stream constraints, payload limits, and permissions affect what a workflow can retrieve or submit.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow queries a narrow LogQL time window or receives prepared log batches, validates the response, transforms selected entries, and routes incident-worthy results to operational systems. Overlapping windows can improve completeness, but downstream handling must tolerate duplicates.
Implementation sequence
Grafana Alerting webhooks
Grafana Alerting supports webhook contact points for configured alert notifications. This is selected outbound event coverage for alert-state notifications, not a universal feed for dashboard, folder, user, data-source, or configuration changes.
Martini implementation pattern
Martini implementation pattern: expose a Martini REST API or webhook-triggered workflow as the contact-point destination, validate and normalize the alert payload, derive an idempotency key from the alert fingerprint or stable identifier, and create or update downstream incidents and annotations.
Implementation sequence
Common Grafana Cloud integration patterns
Pattern 1: Route Grafana alerts to incident management
When to use this pattern
Use this pattern when configured Grafana Alerting notifications should create, update, or resolve incidents in an operational platform. It is appropriate for alert-driven response where firing, resolved, and repeated notifications must be handled consistently.
Integration direction
Example Mapping
| Grafana Cloud Field | Canonical Field | Target Field |
|---|---|---|
| alert.fingerprint | alertKey | correlation_id |
| alert.status | lifecycleState | incident_state |
| labels.severity | severity | priority |
| annotations.summary | summary | short_description |
Martini implementation pattern
Grafana sends a webhook notification to a Martini API. Martini validates the payload, maps alert labels and annotations, checks an idempotency store using the fingerprint, applies severity and ownership rules, and creates or updates the ServiceNow incident. Retryable target failures are retried with backoff, while invalid payloads are rejected and logged.
Martini capabilities used
- REST API exposure
- workflows
- webhook handling
- data mapping
- business rules
- idempotency
- error handling
Pattern 2: Publish deployment annotations to Grafana
When to use this pattern
Use this pattern when deployment, release, or change-management events need to appear on Grafana dashboards for incident correlation and operational analysis.
Integration direction
Example Mapping
| Grafana Cloud Field | Canonical Field | Target Field |
|---|---|---|
| repository.full_name | application | tags.application |
| deployment.environment | environment | tags.environment |
| deployment.sha | releaseVersion | text |
| deployment.completed_at | eventTime | time |
Martini implementation pattern
A source application sends a deployment event to Martini. The workflow validates the application and environment, enriches the event with release metadata, builds an annotation payload, and calls the Grafana HTTP API. A deterministic deployment identifier prevents duplicate annotations during retries.
Martini capabilities used
- API consumption
- workflows
- JSON transformation
- data mapping
- validation
- business rules
- retry handling
Pattern 3: Synchronize dashboards and alert configuration
When to use this pattern
Use this pattern when approved dashboards, folders, data sources, or alert rules must be reconciled between Grafana Cloud environments or with a governance repository.
Integration direction
Example Mapping
| Grafana Cloud Field | Canonical Field | Target Field |
|---|---|---|
| dashboard.uid | dashboardKey | uid |
| dashboard.title | displayName | title |
| folderUid | folderKey | folderUid |
| dashboard.panels[].targets | queryDefinitions | panels[].targets |
Martini implementation pattern
A scheduled Martini workflow retrieves source configuration, preserves compatible dashboard JSON fields, replaces environment-specific data-source and folder references, and submits the transformed definition to the destination. The workflow compares snapshots or checkpoints, handles pagination, and routes permission or validation failures to an error process.
Martini capabilities used
- scheduled workflows
- API consumption
- JSON handling
- mapping and transformation
- reconciliation
- pagination
- error handling
Pattern 4: Turn metrics or logs into business workflows
When to use this pattern
Use this pattern when selected Prometheus metrics or Loki log results should trigger operational, customer-support, or business actions rather than remain only in observability dashboards.
Integration direction
Example Mapping
| Grafana Cloud Field | Canonical Field | Target Field |
|---|---|---|
| metric.labels.service | serviceName | Service__c |
| metric.value | observedValue | Observed_Value__c |
| query.endTime | observedAt | Observed_At__c |
| log.level | severity | Severity__c |
Martini implementation pattern
Martini schedules a bounded metrics or logs query, applies time-window and cardinality controls, evaluates thresholds and business rules, enriches qualifying results, and writes them to the target application. Checkpoints and overlap windows support incremental processing, while stable event keys prevent duplicate downstream actions.
Martini capabilities used
- scheduled workflows
- Prometheus and Loki API consumption
- data mapping
- business rules
- checkpointing
- deduplication
- retry handling
Applications commonly integrated with Grafana Cloud
Grafana Cloud can be connected with operational, engineering, cloud, and business applications to coordinate alerts, deployment context, observability data, and incident workflows. Martini provides the orchestration layer for validating payloads, applying routing rules, transforming data, and maintaining reliable synchronization between Grafana Cloud and these products.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| ServiceNow | Create, update, and resolve incidents from Grafana alerts and associate deployment or operational events with change records. | Grafana Cloud → Martini → ServiceNow | Receive configured Grafana Alerting webhook notifications, normalize alert states and fingerprints, apply deduplication, and create or update ServiceNow incidents. ServiceNow events can also be transformed into Grafana annotations through the Grafana HTTP API. |
| Jira | Create or update engineering issues from actionable alerts and associate incidents or deployments with Grafana context. | Grafana Cloud → Martini → Jira | Use a Martini webhook workflow for selected alerts, map labels and annotations to Jira issue fields, apply severity and ownership rules, and retain the Grafana alert identifier for idempotent updates. |
| PagerDuty | Route selected Grafana alert notifications into on-call schedules and synchronize incident status with operational workflows. | Grafana Cloud → Martini → PagerDuty | Validate Grafana webhook payloads, translate firing and resolved states into PagerDuty incident operations, and use stable alert fingerprints to prevent duplicate incidents. |
| Slack | Deliver selected alert, deployment, and service-health notifications to operational channels. | Grafana Cloud → Martini → Slack | Filter and enrich Grafana alerts in a Martini workflow, format concise channel-specific messages, and route notifications according to service, environment, and severity rules. |
| AWS CloudWatch | Correlate AWS monitoring data with Grafana dashboards and route selected conditions into enterprise workflows. | AWS CloudWatch → Grafana Cloud → Martini | Use Martini to coordinate selected CloudWatch and Grafana metrics workflows, normalize metric dimensions and time windows, and send threshold results to downstream operational applications. |
| Kubernetes | Correlate cluster events, workload metadata, and telemetry with Grafana dashboards and alert workflows. | Kubernetes → Grafana Cloud → Martini | Transform selected Kubernetes deployment or workload events into Grafana annotations, while Martini can consume resulting alert notifications and route them to incident or collaboration systems. |
| GitHub | Add deployment and code-change context to Grafana dashboards and associate alerts with repositories, commits, or releases. | GitHub → Martini → Grafana Cloud | Receive selected GitHub delivery events, map repository and release metadata to Grafana annotation fields, and call the Grafana HTTP API with environment-specific credentials. |
| Salesforce | Send selected service-health or operational metrics into customer-support and account workflows. | Grafana Cloud → Martini → Salesforce | Schedule Prometheus or Loki queries, evaluate thresholds and business rules in Martini, and map qualifying results into Salesforce objects or notifications using the relevant Salesforce API. |
How to build a Grafana Cloud integration in Martini
Objective
Configure the Grafana Cloud stack endpoint, tenant or instance identifier, and the credential required by each service or API area.
Instructions in Martini
- Store service account tokens, access policy tokens, Basic Authentication values, and endpoint configuration as environment-specific Martini secrets
- Use separate credentials and permissions for development, test, and production
- Grant only the organization, folder, dashboard, alerting, or service permissions required by the workflow
Objective
Select an event-driven, scheduled, or API-led starting point based on the Grafana Cloud capability being integrated.
Instructions in Martini
- Use a Martini REST API or webhook-triggered workflow for Grafana Alerting contact-point notifications
- Use a scheduler for dashboard, configuration, metrics, or logs reconciliation
- Use an API-led workflow when another system needs to request Grafana data or configuration
Objective
Receive alert payloads or retrieve the current Grafana, Prometheus, or Loki data within a controlled scope.
Instructions in Martini
- Validate inbound webhook requests before processing them
- Use documented pagination for administrative collections
- Restrict metrics and logs queries to bounded time windows, labels, and result sizes
Objective
Coordinate the calls, lookups, transformations, business decisions, and target writes as a maintainable Martini workflow.
Instructions in Martini
- Separate alert normalization, configuration synchronization, and telemetry query logic into reusable workflow stages
- Branch on alert lifecycle, severity, service, environment, and target availability
- Record checkpoints, source identifiers, and downstream relationships for reconciliation
Objective
Convert Grafana JSON, alert payloads, metric results, or log streams into a canonical model and destination-specific structures.
Instructions in Martini
- Map labels, annotations, timestamps, fingerprints, dashboard references, and query results explicitly
- Preserve compatible unknown dashboard and alert fields when synchronizing configuration
- Normalize timestamps, identifiers, severity values, and environment-specific references
Objective
Apply validation, filtering, deduplication, threshold, ownership, and routing logic before a downstream write or Grafana update.
Instructions in Martini
- Use alert fingerprints or deterministic event keys for idempotency
- Distinguish firing, resolved, pending, and repeated alert states when present
- Apply query, retention, severity, and service ownership rules before forwarding results
Common Grafana Cloud data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Cloud stacks | Tenant environments that provide Grafana and hosted metrics, logs, traces, alerting, and related services. | Environment repositories, governance systems, deployment platforms | Martini stores stack-specific endpoints, tenant identifiers, and credentials as environment configuration and uses them to route workflows to the correct service. |
| Dashboards | JSON-defined visualizations containing panels, variables, queries, and layout configuration. | Other Grafana Cloud environments, governance repositories, deployment pipelines | Martini retrieves, preserves, transforms, and submits dashboard JSON while retaining compatible unknown fields and environment-specific references. |
| Folders | Organize dashboards and, in many cases, alerting resources by team, service, or ownership boundary. | Other Grafana environments, identity and governance systems | Martini synchronizes folder identifiers and titles, resolves destination references, and applies environment-specific ownership or permission rules. |
| Data sources | Configured connections to Prometheus, Loki, Elasticsearch, SQL databases, and cloud monitoring services. | Grafana environments, configuration repositories, platform governance systems | Martini can read or update configuration through the HTTP API when the calling identity has sufficient privileges, while protecting credentials as secrets. |
| Alert rules | Queries and expressions that evaluate conditions and generate alert notifications. | Incident platforms, collaboration tools, other Grafana environments | Martini can synchronize alert definitions, receive their configured webhook notifications, map lifecycle states, and apply deduplication and routing rules. |
| Annotations | Time-associated events such as deployments, incidents, releases, and operational changes displayed on dashboards. | Grafana dashboards, change-management systems, deployment platforms | Martini maps external event metadata to annotation payloads and calls the Grafana HTTP API with deterministic event identifiers where possible. |
Authentication and security considerations
Scoped credentials
Grafana Cloud uses service account tokens and access policy tokens for many API operations. Permissions can be constrained by organization roles, folder permissions, teams, service account roles, and access policy scopes.
Endpoint-specific authentication
Hosted metrics and logs endpoints may use Basic Authentication with an instance or tenant identifier and an access token. The correct credential pattern depends on the Grafana Cloud service and endpoint.
Martini security model
Store Grafana endpoints, tenant identifiers, tokens, and related configuration as environment-specific Martini secrets. Use separate credentials for each environment and grant only the permissions required by the workflow.
Operational considerations for Grafana Cloud integrations
Limits and pagination
Administrative APIs, metrics queries, log queries, and ingestion services can have different limits. Follow pagination metadata, restrict query windows, use bounded concurrency, and split large telemetry payloads into manageable batches.
Retries and idempotency
Retry transient failures with backoff and avoid replaying unsafe writes blindly. Use alert fingerprints, stable identifiers, or deterministic event keys for webhook, annotation, and downstream incident deduplication.
Incremental synchronization
Metrics and logs should use explicit windows and checkpoints. Account for late-arriving telemetry, clock skew, retention, overlapping windows, and duplicate results.
Schema and API changes
Dashboard and alerting JSON structures can evolve. Preserve compatible unknown fields where possible, validate API behavior against the target Grafana Cloud service, and test configuration changes before deployment.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration across systems
Martini coordinates Grafana Cloud APIs, webhook notifications, metrics and logs queries, incident platforms, collaboration tools, and business applications in one maintainable workflow.
Reusable transformation logic
Mappings, validation, enrichment, routing rules, checkpoints, and error handling can be reused across alert, configuration, and telemetry integrations instead of being duplicated in scripts.
Reliable operations
Martini supports scheduled and event-driven execution, controlled retries, idempotency, environment-specific secrets, monitoring, and explicit failure handling for enterprise integration processes.
API-led flexibility
When Grafana Cloud exposes a native HTTP or observability endpoint, Martini can consume it or expose a controlled API façade without requiring a dedicated vendor connector.
Frequently asked questions
Grafana Cloud can integrate through Grafana HTTP APIs, Prometheus-compatible metrics endpoints, Loki-compatible log endpoints, and configured Grafana Alerting webhook contact points. Scheduled workflows can poll and reconcile dashboards, folders, alert rules, metrics, or logs, while webhook workflows can route selected alerts to incident, collaboration, and business applications.
Yes. Martini can consume Grafana Cloud HTTP APIs, Prometheus-compatible metrics APIs, and Loki-compatible log APIs, and can receive configured Grafana Alerting webhook notifications through a Martini API or webhook-triggered workflow. Martini can then map, validate, enrich, and route the resulting data.
No. A dedicated Grafana Cloud connector is not required. Martini can integrate using Grafana Cloud's confirmed native HTTP APIs, Prometheus- and Loki-compatible endpoints, webhook notifications, and authentication methods.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Grafana Cloud. The integration is subject to the provisioned capacity of the Martini environment. Separate Grafana Cloud, infrastructure, telemetry-ingestion, storage, or third-party application costs may apply.
Use Grafana HTTP APIs for dashboards, folders, data sources, alerting resources, annotations, users, teams, and administration. Use Prometheus-compatible APIs for hosted metrics and Loki-compatible APIs for logs. Use webhook contact points for selected Grafana Alerting notifications, and scheduled workflows when no outbound event mechanism is available.
Grafana Alerting supports webhook contact points for configured alert notifications, including alert-state changes and repeated notifications where configured. A universal webhook feed for dashboards, folders, users, data sources, or other object changes was not confirmed, so Martini should use scheduled polling and reconciliation for those changes.
Martini can run scheduled workflows that retrieve current dashboard, folder, alert-rule, metrics, or logs data, compare it with a stored checkpoint or snapshot, map it to a canonical model, and write changes to a target system or another Grafana environment. Incremental windows, pagination, overlap handling, and idempotency rules should be selected according to the data type.
Martini can validate responses and webhook payloads, retry transient failures with backoff, split bounded telemetry batches, and route permanent failures to an error process. Alert fingerprints, stable identifiers, timestamps, or deterministic composite keys can be used to prevent duplicate incidents, annotations, metric actions, or log-derived workflows.
Related Martini documentation
Workflows
Connect Grafana Cloud with Martini
Use Martini to orchestrate Grafana Cloud APIs, alert webhooks, metrics, logs, and enterprise workflows with secure configuration, transformation, and operational controls.