ListCode

ListCode

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

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

fetch('https://developer.synq.io/api/code/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/code/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/code/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/code/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

{
  "codes": [
    {
      "definerIdentifier": {
        "airflowDag": {
          "integrationId": "<string>",
          "dagId": "<string>"
        },
        "entityId": "<string>"
      },
      "stateAt": "2023-01-15T01:30:15.01Z",
      "definerSynqPath": "<string>",
      "definerEntityType": "ENTITY_TYPE_UNSPECIFIED",
      "codeType": "CODE_TYPE_UNSPECIFIED",
      "sqlDialect": "SQL_DIALECT_UNSPECIFIED",
      "content": "<string>",
      "codeName": "<string>",
      "filePath": "<string>",
      "definerPlatform": "DATA_PLATFORM_TYPE_UNSPECIFIED",
      "hasExecutionError": true,
      "executionError": "<string>",
      "isTruncated": true,
      "originalSizeBytes": 123
    }
  ],
  "identifiers": [
    {
      "airflowDag": {
        "integrationId": "<string>",
        "dagId": "<string>"
      },
      "entityId": "<string>"
    }
  ],
  "synqPaths": [
    "<string>"
  ],
  "unavailableSources": [
    {
      "source": "CODE_SOURCE_UNSPECIFIED",
      "message": "<string>"
    }
  ]
}

GET

api

code

ListCode

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

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

fetch('https://developer.synq.io/api/code/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/code/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/code/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/code/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

{
  "codes": [
    {
      "definerIdentifier": {
        "airflowDag": {
          "integrationId": "<string>",
          "dagId": "<string>"
        },
        "entityId": "<string>"
      },
      "stateAt": "2023-01-15T01:30:15.01Z",
      "definerSynqPath": "<string>",
      "definerEntityType": "ENTITY_TYPE_UNSPECIFIED",
      "codeType": "CODE_TYPE_UNSPECIFIED",
      "sqlDialect": "SQL_DIALECT_UNSPECIFIED",
      "content": "<string>",
      "codeName": "<string>",
      "filePath": "<string>",
      "definerPlatform": "DATA_PLATFORM_TYPE_UNSPECIFIED",
      "hasExecutionError": true,
      "executionError": "<string>",
      "isTruncated": true,
      "originalSizeBytes": 123
    }
  ],
  "identifiers": [
    {
      "airflowDag": {
        "integrationId": "<string>",
        "dagId": "<string>"
      },
      "entityId": "<string>"
    }
  ],
  "synqPaths": [
    "<string>"
  ],
  "unavailableSources": [
    {
      "source": "CODE_SOURCE_UNSPECIFIED",
      "message": "<string>"
    }
  ]
}

Authorizations

Authorization

string

header

required

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

Query Parameters

id.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

id.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.

id.dbtCoreNode.nodeId

string

required

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

id.dbtCloudNode.projectId

string

required

Your dbt Cloud project id

id.dbtCloudNode.accountId

string

Your dbt Cloud account id

id.dbtCloudNode.nodeId

string

required

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

id.bigqueryTable.project

string

required

BigQuery project

id.bigqueryTable.dataset

string

required

BigQuery dataset id

id.bigqueryTable.table

string

required

BigQuery table name

id.snowflakeTable.account

string

required

Snowflake account

id.snowflakeTable.database

string

required

Snowflake database

id.snowflakeTable.schema

string

required

Snowflake schema

id.snowflakeTable.table

string

required

Snowflake table

id.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

id.redshiftTable.database

string

required

Redshift database

id.redshiftTable.schema

string

required

Redshift schema

id.redshiftTable.table

string

required

Redshift table

id.postgresTable.host

string

required

Postgres hostname without port

id.postgresTable.database

string

required

Postgres database

id.postgresTable.schema

string

required

Postgres schema

id.postgresTable.table

string

required

Postgres table

id.mysqlTable.host

string

required

Mysql hostname without port

id.mysqlTable.schema

string

required

Mysql database

id.mysqlTable.table

string

required

Mysql table

id.clickhouseTable.host

string

required

Clickhouse hostname without port

id.clickhouseTable.schema

string

required

Clickhouse database

id.clickhouseTable.table

string

required

Clickhouse table

id.airflowDag.integrationId

string

required

Coalesce Quality integration_id that identifies the Airflow instance

id.airflowDag.dagId

string

required

Airflow dag_id that identifies the DAG

id.airflowTask.integrationId

string

required

Coalesce Quality integration_id that identifies the Airflow instance

id.airflowTask.dagId

string

required

Airflow dag_id that identifies the DAG

id.airflowTask.taskId

string

required

Airflow task_id that identifies the task within the DAG

id.custom.id

string

required

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

id.dataproduct.id

string<uuid>

required

Dataproduct id that identifies the Dataproduct

id.synqPath.path

string

required

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

id.databricksTable.workspace

string

required

URL of Databricks workspace

id.databricksTable.catalog

string

required

Databricks catalog

id.databricksTable.schema

string

required

Databricks schema

id.databricksTable.table

string

required

Databricks table or view

id.trinoTable.host

string

required

Hostname of the Trino instance

id.trinoTable.catalog

string

required

Trino catalog

id.trinoTable.schema

string

required

Trino schema

id.trinoTable.table

string

required

Trino table or view

id.sqlMeshModel.integrationId

string<uuid>

required

Coalesce Quality integration_id that identifies the dbt Core project

id.sqlMeshModel.fqn

string

required

SQLMesh model fully qualified name

id.sqlMeshAudit.integrationId

string<uuid>

required

Coalesce Quality integration_id that identifies the dbt Core project

id.sqlMeshAudit.fqn

string

required

SQLMesh model fully qualified name

id.sqlMeshAudit.auditId

string

required

Identifier of the audit

id.monitor.monitoredId.mssqlTable.host

string

required

Hostname of the SQL Server instance

id.monitor.monitoredId.mssqlTable.database

string

required

SQL Server database

id.monitor.monitoredId.mssqlTable.schema

string

required

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

id.monitor.monitoredId.mssqlTable.table

string

required

SQL Server table or view

id.monitor.monitoredId.oracleTable.host

string

required

Hostname of the Oracle instance

id.monitor.monitoredId.oracleTable.serviceName

string

required

Oracle service name (PDB)

id.monitor.monitoredId.oracleTable.schema

string

required

Oracle schema (= owning user)

id.monitor.monitoredId.oracleTable.table

string

required

Oracle table or view

id.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.

id.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.

id.monitor.monitoredId.athenaTable.database

string

required

Glue database (the namespace users typically filter on).

id.monitor.monitoredId.athenaTable.table

string

required

Glue table or view name.

id.monitor.monitoredId.savedView.id

string<uuid>

required

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

id.monitor.monitoredId.fabricTable.instance

string

required

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

id.monitor.monitoredId.fabricTable.database

string

required

Fabric warehouse / lakehouse (database).

id.monitor.monitoredId.fabricTable.schema

string

required

Schema within the database.

id.monitor.monitoredId.fabricTable.table

string

required

Table or view name.

id.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.

id.monitor.monitoredId.fabricTable.tenantId

string

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

id.monitor.monitoredId.db2Table.host

string

required

Host name of the Db2 server

id.monitor.monitoredId.db2Table.database

string

required

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

id.monitor.monitoredId.db2Table.schema

string

required

Db2 schema (e.g. "DB2INST1")

id.monitor.monitoredId.db2Table.table

string

required

Db2 table or view

id.monitor.monitorId

string

required

Identifier of the monitor

id.monitor.segment

string

Optional monitor segmentation identifier

id.monitor.integrationId

string

deprecated

Coalesce Quality integration_id of the monitored identifier

Response

200 - application/json

Success

ListCodeResponse is the response message for the ListCode method.

codes

Code · object[]

List of code artifacts associated with the requested entity. Each code artifact includes its content, type, and metadata about when it was captured.

Show child attributes

identifiers

Identifier · object[]

Identifier is a unique reference to an entity in Coalesce Quality system. Entity identifiers are designed to closely mimic identifiers used by data platforms and tools. To construct an identifier, you need to know the kind of the entity and the ids that you would normally use to identify it in the data platform or tool. For example, to identify a table in BigQuery, you would need to know the project, dataset, and table names.

Every identifier the API RETURNS also carries entity_id, the entity's opaque id. Read it when you just need to name the entity again — it is one string for every platform, where the structured variants below only cover the platforms that have one.

Show child attributes

synqPaths

string[]

Minimum string length: 1

unavailableSources

CodeSourceError · object[]

Sources that could not be read while assembling this response. Empty on a complete response, which is the normal case.

Code is composed from several independent sources, so one of them being briefly unavailable degrades the response rather than failing it: the codes that were read are returned, and the source that was not is named here. Retry to pick up what is missing.

An empty codes always means the entity has no code, never that a source was unavailable — a request that could read nothing at all returns an error rather than an empty response, because the two are otherwise indistinguishable.

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