ListIncidents

ListIncidents

curl --request GET \
  --url https://developer.synq.io/api/incidents/v1 \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://developer.synq.io/api/incidents/v1', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://developer.synq.io/api/incidents/v1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://developer.synq.io/api/incidents/v1"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://developer.synq.io/api/incidents/v1")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "incidents": [
    {
      "id": "<string>",
      "index": 123,
      "name": "<string>",
      "issueIds": [
        "<string>"
      ],
      "createdBy": {
        "name": "<string>",
        "email": {
          "userEmail": "jsmith@example.com"
        },
        "via": "VIA_UNSPECIFIED"
      },
      "owner": {
        "id": "<string>",
        "firstName": "<string>",
        "lastName": "<string>",
        "email": "<string>",
        "identities": [
          "<string>"
        ],
        "roles": [
          "USER_ROLE_UNSPECIFIED"
        ],
        "status": "USER_STATUS_UNSPECIFIED",
        "lastLoginAt": "2023-01-15T01:30:15.01Z",
        "createdAt": "2023-01-15T01:30:15.01Z"
      },
      "createdAt": "2023-01-15T01:30:15.01Z",
      "updatedBy": {
        "name": "<string>",
        "email": {
          "userEmail": "jsmith@example.com"
        },
        "via": "VIA_UNSPECIFIED"
      },
      "updatedAt": "2023-01-15T01:30:15.01Z",
      "state": "STATE_UNSPECIFIED",
      "comments": [
        {
          "id": "<string>",
          "message": "<string>",
          "createdAt": "2023-01-15T01:30:15.01Z",
          "actor": {
            "name": "<string>",
            "email": {
              "userEmail": "jsmith@example.com"
            },
            "via": "VIA_UNSPECIFIED"
          }
        }
      ]
    }
  ]
}

GET

api

incidents

ListIncidents

curl --request GET \
  --url https://developer.synq.io/api/incidents/v1 \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://developer.synq.io/api/incidents/v1', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://developer.synq.io/api/incidents/v1",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://developer.synq.io/api/incidents/v1"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://developer.synq.io/api/incidents/v1")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "incidents": [
    {
      "id": "<string>",
      "index": 123,
      "name": "<string>",
      "issueIds": [
        "<string>"
      ],
      "createdBy": {
        "name": "<string>",
        "email": {
          "userEmail": "jsmith@example.com"
        },
        "via": "VIA_UNSPECIFIED"
      },
      "owner": {
        "id": "<string>",
        "firstName": "<string>",
        "lastName": "<string>",
        "email": "<string>",
        "identities": [
          "<string>"
        ],
        "roles": [
          "USER_ROLE_UNSPECIFIED"
        ],
        "status": "USER_STATUS_UNSPECIFIED",
        "lastLoginAt": "2023-01-15T01:30:15.01Z",
        "createdAt": "2023-01-15T01:30:15.01Z"
      },
      "createdAt": "2023-01-15T01:30:15.01Z",
      "updatedBy": {
        "name": "<string>",
        "email": {
          "userEmail": "jsmith@example.com"
        },
        "via": "VIA_UNSPECIFIED"
      },
      "updatedAt": "2023-01-15T01:30:15.01Z",
      "state": "STATE_UNSPECIFIED",
      "comments": [
        {
          "id": "<string>",
          "message": "<string>",
          "createdAt": "2023-01-15T01:30:15.01Z",
          "actor": {
            "name": "<string>",
            "email": {
              "userEmail": "jsmith@example.com"
            },
            "via": "VIA_UNSPECIFIED"
          }
        }
      ]
    }
  ]
}

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Query Parameters

time.field

enum<string>

Available options:

FIELD_UNSPECIFIED,

FIELD_CREATED_AT,

FIELD_UPDATED_AT

time.from.seconds

Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be between -315576000000 and 315576000000 inclusive (which corresponds to 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).

time.from.nanos

integer<int32>

Non-negative fractions of a second at nanosecond resolution. This field is the nanosecond portion of the duration, not an alternative to seconds. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be between 0 and 999,999,999 inclusive.

sort.sortBy

enum<string>

Available options:

FIELD_UNSPECIFIED,

FIELD_CREATED_AT,

FIELD_UPDATED_AT

sort.order

enum<string>

Available options:

ORDER_UNSPECIFIED,

ORDER_ASC,

ORDER_DESC

pagination.cursor

string

Opaque cursor token for the next page of results. If not provided, returns the first page. This is an encoded token that should be passed as-is from the previous PageInfo.last_id.

pagination.pageSize

integer<int32>

Maximum number of items to return in a single page. If not provided, defaults vary per API.

Required range: x >= 0

states

enum<string>[]

Filter by states

Available options:

STATE_UNSPECIFIED,

STATE_OPEN,

STATE_CLOSED,

STATE_CANCELLED

affectedEntities.entityId

string

Opaque id of the entity, set on every identifier the API returns. Round-trip it verbatim; the format is not part of this contract and may change, and it is never constructed by hand.

OUTPUT ONLY. On a request this field is ignored — the structured variant is what resolves. That is what lets you hand an identifier straight back unchanged, or edit its structured fields, without the two disagreeing about which entity you meant. To name an entity BY opaque id on a request, set the synq_path variant to that id: it carries exactly this string, and it is also how an entity whose platform has no structured variant is named.

Maximum string length: 1024

affectedEntities.dbtCoreNode.integrationId

string

required

Opaque identifier of the dbt Core project. Usually the Coalesce Quality integration id (a UUID), but may also be the dbt project name from manifest.json when the integration is configured to identify assets by project name. Treat it as an opaque string, not a UUID.

affectedEntities.dbtCoreNode.nodeId

string

required

Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)

affectedEntities.dbtCloudNode.projectId

string

required

Your dbt Cloud project id

affectedEntities.dbtCloudNode.accountId

string

Your dbt Cloud account id

affectedEntities.dbtCloudNode.nodeId

string

required

Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)

affectedEntities.bigqueryTable.project

string

required

BigQuery project

affectedEntities.bigqueryTable.dataset

string

required

BigQuery dataset id

affectedEntities.bigqueryTable.table

string

required

BigQuery table name

affectedEntities.snowflakeTable.account

string

required

Snowflake account

affectedEntities.snowflakeTable.database

string

required

Snowflake database

affectedEntities.snowflakeTable.schema

string

required

Snowflake schema

affectedEntities.snowflakeTable.table

string

required

Snowflake table

affectedEntities.redshiftTable.cluster

string

Required. Host of the Redshift endpoint, as in the connection, for example my-cluster.abc123.eu-west-1.redshift.amazonaws.com. A port suffix is accepted and ignored. The bare cluster name (my-cluster) is not enough, because one name can exist in more than one account or region. A response returns the host in its normalized form, which is also accepted on input.

The rule below also refuses an empty value. It is not required, because required stops the other rules and its error does not say what to send. Required. Host of the Redshift endpoint, as in the connection, for example my-cluster.abc123.eu-west-1.redshift.amazonaws.com. A port suffix is accepted and ignored. The bare cluster name (my-cluster) is not enough, because one name can exist in more than one account or region. A response returns the host in its normalized form, which is also accepted on input.

The rule below also refuses an empty value. It is not required, because required stops the other rules and its error does not say what to send. redshift_table.cluster.full_host // cluster must be the full host of the Redshift endpoint from the connection, for example my-cluster.abc123.eu-west-1.redshift.amazonaws.com

affectedEntities.redshiftTable.database

string

required

Redshift database

affectedEntities.redshiftTable.schema

string

required

Redshift schema

affectedEntities.redshiftTable.table

string

required

Redshift table

affectedEntities.postgresTable.host

string

required

Postgres hostname without port

affectedEntities.postgresTable.database

string

required

Postgres database

affectedEntities.postgresTable.schema

string

required

Postgres schema

affectedEntities.postgresTable.table

string

required

Postgres table

affectedEntities.mysqlTable.host

string

required

Mysql hostname without port

affectedEntities.mysqlTable.schema

string

required

Mysql database

affectedEntities.mysqlTable.table

string

required

Mysql table

affectedEntities.clickhouseTable.host

string

required

Clickhouse hostname without port

affectedEntities.clickhouseTable.schema

string

required

Clickhouse database

affectedEntities.clickhouseTable.table

string

required

Clickhouse table

affectedEntities.airflowDag.integrationId

string

required

Coalesce Quality integration_id that identifies the Airflow instance

affectedEntities.airflowDag.dagId

string

required

Airflow dag_id that identifies the DAG

affectedEntities.airflowTask.integrationId

string

required

Coalesce Quality integration_id that identifies the Airflow instance

affectedEntities.airflowTask.dagId

string

required

Airflow dag_id that identifies the DAG

affectedEntities.airflowTask.taskId

string

required

Airflow task_id that identifies the task within the DAG

affectedEntities.custom.id

string

required

Id that identifies the custom entity The Id should be unique within the custom entity Identifier.

affectedEntities.dataproduct.id

string<uuid>

required

Dataproduct id that identifies the Dataproduct

affectedEntities.synqPath.path

string

required

Coalesce Quality path that identifies the Coalesce Quality entity, needs to be one of supported paths

affectedEntities.databricksTable.workspace

string

required

URL of Databricks workspace

affectedEntities.databricksTable.catalog

string

required

Databricks catalog

affectedEntities.databricksTable.schema

string

required

Databricks schema

affectedEntities.databricksTable.table

string

required

Databricks table or view

affectedEntities.trinoTable.host

string

required

Hostname of the Trino instance

affectedEntities.trinoTable.catalog

string

required

Trino catalog

affectedEntities.trinoTable.schema

string

required

Trino schema

affectedEntities.trinoTable.table

string

required

Trino table or view

affectedEntities.sqlMeshModel.integrationId

string<uuid>

required

Coalesce Quality integration_id that identifies the dbt Core project

affectedEntities.sqlMeshModel.fqn

string

required

SQLMesh model fully qualified name

affectedEntities.sqlMeshAudit.integrationId

string<uuid>

required

Coalesce Quality integration_id that identifies the dbt Core project

affectedEntities.sqlMeshAudit.fqn

string

required

SQLMesh model fully qualified name

affectedEntities.sqlMeshAudit.auditId

string

required

Identifier of the audit

affectedEntities.monitor.monitoredId.mssqlTable.host

string

required

Hostname of the SQL Server instance

affectedEntities.monitor.monitoredId.mssqlTable.database

string

required

SQL Server database

affectedEntities.monitor.monitoredId.mssqlTable.schema

string

required

SQL Server schema (e.g. "dbo")

affectedEntities.monitor.monitoredId.mssqlTable.table

string

required

SQL Server table or view

affectedEntities.monitor.monitoredId.oracleTable.host

string

required

Hostname of the Oracle instance

affectedEntities.monitor.monitoredId.oracleTable.serviceName

string

required

Oracle service name (PDB)

affectedEntities.monitor.monitoredId.oracleTable.schema

string

required

Oracle schema (= owning user)

affectedEntities.monitor.monitoredId.oracleTable.table

string

required

Oracle table or view

affectedEntities.monitor.monitoredId.athenaTable.instance

string

required

AWS account and region the Athena workgroup runs in, formatted as "." (e.g. "123456789012.eu-west-1"). Auto-derived from sts:GetCallerIdentity at integration setup time.

affectedEntities.monitor.monitoredId.athenaTable.catalog

string

required

Glue Data Catalog name. Almost always "AwsDataCatalog" — the default catalog for Athena unless the customer registered a federated catalog.

affectedEntities.monitor.monitoredId.athenaTable.database

string

required

Glue database (the namespace users typically filter on).

affectedEntities.monitor.monitoredId.athenaTable.table

string

required

Glue table or view name.

affectedEntities.monitor.monitoredId.savedView.id

string<uuid>

required

Saved view id (client-supplied UUID) that identifies the saved view

affectedEntities.monitor.monitoredId.fabricTable.instance

string

required

Workspace SQL analytics endpoint host, e.g. ".datawarehouse.fabric.microsoft.com".

affectedEntities.monitor.monitoredId.fabricTable.database

string

required

Fabric warehouse / lakehouse (database).

affectedEntities.monitor.monitoredId.fabricTable.schema

string

required

Schema within the database.

affectedEntities.monitor.monitoredId.fabricTable.table

string

required

Table or view name.

affectedEntities.monitor.monitoredId.fabricTable.workspaceId

string

Fabric workspace GUID, decoded from the endpoint host in instance. Optional and informational: the table is addressed by instance/database/schema/table, so leave it empty if you don't have it — it does not affect how the identifier resolves.

affectedEntities.monitor.monitoredId.fabricTable.tenantId

string

Entra (Azure AD) tenant GUID, decoded from the endpoint host in instance. Optional and informational, like workspace_id.

affectedEntities.monitor.monitoredId.db2Table.host

string

required

Host name of the Db2 server

affectedEntities.monitor.monitoredId.db2Table.database

string

required

Database name or alias, as in CONNECT TO <database>

affectedEntities.monitor.monitoredId.db2Table.schema

string

required

Db2 schema (e.g. "DB2INST1")

affectedEntities.monitor.monitoredId.db2Table.table

string

required

Db2 table or view

affectedEntities.monitor.monitorId

string

required

Identifier of the monitor

affectedEntities.monitor.segment

string

Optional monitor segmentation identifier

affectedEntities.monitor.integrationId

string

deprecated

Coalesce Quality integration_id of the monitored identifier

Response

200 - application/json

Success

incidents

Incident · object[]

Show child attributes

Get Started

Alerts

Monitors

Monitors Types

Reconciliations

Data Products

Scout AI

Ownership

Incidents

Analytics

Query activity

Lineage

BI Integrations

Data Warehouse Integrations

Transactional databases

Code Integrations

dbt Integrations

SQLMesh Integrations

Coalesce Integrations

Orchestration Tool Integrations

Alerting Integrations

Catalogs

Google Cloud Integrations

Admin

Security

Support

Developer API

Authorizations

Query Parameters

Response