Get Connectors

TypeScript (SDK)

import { Textql } from "@textql/sdk";

const textql = new Textql({
  apiKey: process.env["TEXTQL_API_KEY"] ?? "",
});

async function run() {
  const result = await textql.connectors.getConnectors({
    body: {},
  });

  console.log(result);
}

run();

import os
from textql_sdk import Textql


with Textql(
    api_key=os.getenv("TEXTQL_API_KEY", ""),
) as textql:

    res = textql.connectors.get_connectors(body={})

    # Handle response
    print(res)

curl --request POST \
  --url https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors \
  --header 'Connect-Protocol-Version: <connect-protocol-version>' \
  --header 'Content-Type: application/json' \
  --header 'tql_api_key: <api-key>' \
  --data '{}'

const options = {
  method: 'POST',
  headers: {
    'Connect-Protocol-Version': '<connect-protocol-version>',
    tql_api_key: '<api-key>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({})
};

fetch('https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors', 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://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "Connect-Protocol-Version: <connect-protocol-version>",
    "Content-Type: application/json",
    "tql_api_key: <api-key>"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Connect-Protocol-Version", "<connect-protocol-version>")
	req.Header.Add("tql_api_key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors")
  .header("Connect-Protocol-Version", "<connect-protocol-version>")
  .header("tql_api_key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors")

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

request = Net::HTTP::Post.new(url)
request["Connect-Protocol-Version"] = '<connect-protocol-version>'
request["tql_api_key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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

{
  "connectors": [
    {
      "athenaMetadata": {
        "region": "<string>",
        "database": "<string>",
        "workgroup": "<string>",
        "s3OutputLocation": "<string>",
        "athenaAuth": {
          "accessKey": {
            "accessKeyId": "<string>",
            "secretAccessKey": "<string>"
          }
        },
        "catalog": "<string>"
      },
      "id": 123,
      "name": "<string>",
      "connectorType": "CONNECTOR_TYPE_UNSPECIFIED",
      "memberId": "<string>",
      "createdAt": "2023-01-15T01:30:15.01Z",
      "isExample": true,
      "allowSqlWriteOperations": true,
      "authStrategy": "<string>",
      "authenticatedByMemberId": "<string>",
      "memberAuthenticated": true,
      "memberAuthUsername": "<string>",
      "includeDbSessionMetadata": true,
      "isPublic": true
    }
  ],
  "unavailableConnectorTypes": [
    "CONNECTOR_TYPE_UNSPECIFIED"
  ],
  "teradataUploadRequired": true
}

{
  "code": "not_found",
  "message": "<string>",
  "details": [
    {
      "type": "<string>",
      "value": "<string>",
      "debug": {}
    }
  ]
}

POST

textql.rpc.public.connector.ConnectorService

GetConnectors

TypeScript (SDK)

import { Textql } from "@textql/sdk";

const textql = new Textql({
  apiKey: process.env["TEXTQL_API_KEY"] ?? "",
});

async function run() {
  const result = await textql.connectors.getConnectors({
    body: {},
  });

  console.log(result);
}

run();

import os
from textql_sdk import Textql


with Textql(
    api_key=os.getenv("TEXTQL_API_KEY", ""),
) as textql:

    res = textql.connectors.get_connectors(body={})

    # Handle response
    print(res)

curl --request POST \
  --url https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors \
  --header 'Connect-Protocol-Version: <connect-protocol-version>' \
  --header 'Content-Type: application/json' \
  --header 'tql_api_key: <api-key>' \
  --data '{}'

const options = {
  method: 'POST',
  headers: {
    'Connect-Protocol-Version': '<connect-protocol-version>',
    tql_api_key: '<api-key>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({})
};

fetch('https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors', 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://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "Connect-Protocol-Version: <connect-protocol-version>",
    "Content-Type: application/json",
    "tql_api_key: <api-key>"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Connect-Protocol-Version", "<connect-protocol-version>")
	req.Header.Add("tql_api_key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors")
  .header("Connect-Protocol-Version", "<connect-protocol-version>")
  .header("tql_api_key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://app.textql.com/rpc/public/textql.rpc.public.connector.ConnectorService/GetConnectors")

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

request = Net::HTTP::Post.new(url)
request["Connect-Protocol-Version"] = '<connect-protocol-version>'
request["tql_api_key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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

{
  "connectors": [
    {
      "athenaMetadata": {
        "region": "<string>",
        "database": "<string>",
        "workgroup": "<string>",
        "s3OutputLocation": "<string>",
        "athenaAuth": {
          "accessKey": {
            "accessKeyId": "<string>",
            "secretAccessKey": "<string>"
          }
        },
        "catalog": "<string>"
      },
      "id": 123,
      "name": "<string>",
      "connectorType": "CONNECTOR_TYPE_UNSPECIFIED",
      "memberId": "<string>",
      "createdAt": "2023-01-15T01:30:15.01Z",
      "isExample": true,
      "allowSqlWriteOperations": true,
      "authStrategy": "<string>",
      "authenticatedByMemberId": "<string>",
      "memberAuthenticated": true,
      "memberAuthUsername": "<string>",
      "includeDbSessionMetadata": true,
      "isPublic": true
    }
  ],
  "unavailableConnectorTypes": [
    "CONNECTOR_TYPE_UNSPECIFIED"
  ],
  "teradataUploadRequired": true
}

{
  "code": "not_found",
  "message": "<string>",
  "details": [
    {
      "type": "<string>",
      "value": "<string>",
      "debug": {}
    }
  ]
}

Authorizations

tql_api_key

string

header

required

Headers

Connect-Protocol-Version

enum<string>

default:1

required

Define the version of the Connect protocol

Available options:

1

Allowed value: "1"

Connect-Timeout-Ms

number

Define the timeout, in ms

Body

application/json

The body is of type GetConnectorsRequest · object.

Response

Success

connectors

Connector · object[]

Show child attributes

unavailableConnectorTypes

enum<string>[]

Available options:

CONNECTOR_TYPE_UNSPECIFIED,

REDSHIFT,

SNOWFLAKE,

BIGQUERY,

AZURE_SYNAPSE,

AURORA,

TABLEAU,

DATABRICKS,

SUPABASE,

POSTGRES,

MOTHERDUCK,

CLICKHOUSE,

MYSQL,

ATHENA,

GOOGLE_DRIVE,

POWERBI,

SQL_SERVER,

MICROSOFT_365,

SAP_HANA,

ORACLE,

GMAIL,

ANA_INTERNAL,

TRINO,

GOOGLE_CALENDAR,

GOOGLE,

DREMIO,

EXASOL,

FIREBOLT,

KDB,

MONGODB,

ANA_BILLING,

TERADATA

teradataUploadRequired

boolean

SDK

Agent Service

Api O Auth Service

App Service

Audit Log Service

Chat Service

Connector Service

Dashboard Service

Dataset Service

Harness Service

MCP Service

Metrics Export Service

Observability Service

Ontology Management Service

Playbook Service

Power BI Service

RBAC Service

Sandbox Admin Service

Sandbox Capability Service

Sandbox Exec Service

Sandbox Query Service

Scim Service

Secret Service

Settings Service

Slack Service

Tableau Service

Teams Service

Authorizations

Headers

Body

Response