Integrations

10 endpoints. Every path below is relative to the API base URL and already includes the /api/v1 prefix — see conventions for authentication, pagination, errors and idempotency.

	Endpoint
GET	`/integrations`	The connect gallery: connectable integrations by category, with this org's connections
GET	`/integrations/{slug}`	One catalogue entry, including its declared action schemas
GET	`/integrations/connections`	List this organization's integration connections
POST	`/integrations/connections`	Connect an integration, encrypting any supplied secrets into a credential row, and return the connection
GET	`/integrations/connections/{connection}`	Retrieve one integration connection; secrets live in the credential row and are not returned
DELETE	`/integrations/connections/{connection}`	Disconnect an integration: revoke the OAuth grant, wipe and delete the credential, drop the connection
POST	`/integrations/connections/{connection}/actions/{action}`	Run one of the connector's declared actions and return the connector's result envelope
POST	`/integrations/connections/{connection}/sync`	Pull remote records from the connector into CallAgent and return the sync result
POST	`/integrations/connections/{connection}/test`	Make a cheap read-only call through the connection to prove the stored credential still works
GET	`/integrations/tools`	List the connector actions this organization's connected integrations expose to assistants as tools

Endpoints

The connect gallery: connectable integrations by category, with this org's connections

GET/integrations

No scope is enforced in the handler — any valid key may call it.
Enforces no scope. data is an object keyed by category, not an array, and connectors whose maturity is not implemented are omitted entirely.

cURLJavaScriptPHPPython

bash

curl -X GET "$CALLAGENT_API_URL/integrations" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations`, {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.get(
    f"{os.environ['CALLAGENT_API_URL']}/integrations",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	`data`-wrapped object

Example response, generated from the schema:

json

{
  "data": {}
}

One catalogue entry, including its declared action schemas

GET/integrations/{slug}

No scope is enforced in the handler — any valid key may call it.
Only connectors with maturity implemented resolve; a registered but unimplemented connector 404s here even though it exists in code.

Path parameters

Name	Type	Required	Notes
`slug`	string	yes

cURLJavaScriptPHPPython

bash

curl -X GET "$CALLAGENT_API_URL/integrations/google-calendar" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/google-calendar`, {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/google-calendar');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.get(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/google-calendar",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	`data`-wrapped object

Errors

Status	When it happens
`404`	No connectable integration with that slug

Example response, generated from the schema:

json

{
  "data": {
    "slug": "string",
    "name": "Support Line",
    "category": "string",
    "description": "string",
    "auth_type": "string",
    "auth_fields": {},
    "default_scopes": {},
    "capabilities": {},
    "documentation_url": "https://example.com/hook"
  }
}

List this organization's integration connections

GET/integrations/connections

No scope is enforced in the handler — any valid key may call it.
Enforces no scope — there is no integration.read in the vocabulary, so any authenticated key can list connections. The integration filter matches the connector slug.

cURLJavaScriptPHPPython

bash

curl -X GET "$CALLAGENT_API_URL/integrations/connections" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections`, {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.get(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	Array of `IntegrationConnectionResource`

Example response, generated from the schema:

json

{
  "data": [
    {
      "id": "01JQ0000000000000000000000",
      "object": "string",
      "integration": "string",
      "name": "Support Line",
      "status": "string",
      "active": true,
      "config": {},
      "granted_capabilities": {},
      "auth": "oauth2",
      "connected_at": "2026-01-01T12:00:00+00:00",
      "last_tested_at": "2026-01-01T12:00:00+00:00",
      "last_test_status": "string",
      "last_synced_at": "2026-01-01T12:00:00+00:00",
      "last_error": "string",
      "created_at": "2026-01-01T12:00:00+00:00"
    }
  ]
}

Connect an integration, encrypting any supplied secrets into a credential row, and return the connection

POST/integrations/connections

API-key connectors take their credentials in secrets, which are encrypted immediately and never returned. OAuth connectors take an oauth_connection_id from a completed authorization.

Requires integration.write.
A connector whose maturity is not implemented is refused with 422 invalid_integration. Missing catalogue rows 404 via firstOrFail, which the spec does not declare.

Request body

Field	Type	Required	Notes
`integration`	string	yes	max 64 chars
`name`	string	yes	max 255 chars
`secrets`	string[] \| null	—
`config`	string[] \| null	—
`oauth_connection_id`	string \| null	—

cURLJavaScriptPHPPython

bash

curl -X POST "$CALLAGENT_API_URL/integrations/connections" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
       "integration": "string",
       "name": "Support Line",
       "oauth_connection_id": "01JQ0000000000000000000000"
     }'

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "integration": "string",
    "name": "Support Line",
    "oauth_connection_id": "01JQ0000000000000000000000"
  }),
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
    'integration' => 'string',
    'name' => 'Support Line',
    'oauth_connection_id' => '01JQ0000000000000000000000',
]),
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.post(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    json={
      "integration": "string",
      "name": "Support Line",
      "oauth_connection_id": "01JQ0000000000000000000000"
    },
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`201`	`data`-wrapped object

Errors

Status	When it happens
`403`	The presenting API key does not carry the integration.write scope
`404`	The connector exists in code but has no row in the integrations catalogue
`422`	Validation failed, the connector slug is unknown, or the connector is not implemented yet

Example response, generated from the schema:

json

{
  "data": {
    "id": "01JQ0000000000000000000000",
    "object": "string",
    "integration": "string",
    "name": "Support Line",
    "status": "string",
    "active": true,
    "config": {},
    "granted_capabilities": {},
    "auth": "oauth2",
    "connected_at": "2026-01-01T12:00:00+00:00",
    "last_tested_at": "2026-01-01T12:00:00+00:00",
    "last_test_status": "string",
    "last_synced_at": "2026-01-01T12:00:00+00:00",
    "last_error": "string",
    "created_at": "2026-01-01T12:00:00+00:00"
  }
}

Retrieve one integration connection; secrets live in the credential row and are not returned

GET/integrations/connections/{connection}

No scope is enforced in the handler — any valid key may call it.
Enforces no scope, unlike every write action on the same resource.

Path parameters

Name	Type	Required	Notes
`connection`	string	yes	The connection ID

cURLJavaScriptPHPPython

bash

curl -X GET "$CALLAGENT_API_URL/integrations/connections/01JQ0000000000000000000000" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections/01JQ0000000000000000000000`, {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections/01JQ0000000000000000000000');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.get(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections/01JQ0000000000000000000000",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	`IntegrationConnectionResource`

Errors

Status	When it happens
`404`	No such connection in this organization

Example response, generated from the schema:

json

{
  "data": {
    "id": "01JQ0000000000000000000000",
    "object": "string",
    "integration": "string",
    "name": "Support Line",
    "status": "string",
    "active": true,
    "config": {},
    "granted_capabilities": {},
    "auth": "oauth2",
    "connected_at": "2026-01-01T12:00:00+00:00",
    "last_tested_at": "2026-01-01T12:00:00+00:00",
    "last_test_status": "string",
    "last_synced_at": "2026-01-01T12:00:00+00:00",
    "last_error": "string",
    "created_at": "2026-01-01T12:00:00+00:00"
  }
}

Disconnect an integration: revoke the OAuth grant, wipe and delete the credential, drop the connection

DELETE/integrations/connections/{connection}

Requires integration.write.
This response is not data-wrapped.
The credential's ciphertext is cleared before the row is soft-deleted, so the disconnect leaves no usable key material behind.

Path parameters

Name	Type	Required	Notes
`connection`	string	yes	The connection ID

cURLJavaScriptPHPPython

bash

curl -X DELETE "$CALLAGENT_API_URL/integrations/connections/01JQ0000000000000000000000" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections/01JQ0000000000000000000000`, {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections/01JQ0000000000000000000000');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.delete(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections/01JQ0000000000000000000000",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`204`	No content

Errors

Status	When it happens
`403`	The presenting API key does not carry the integration.write scope
`404`	No such connection in this organization

Run one of the connector's declared actions and return the connector's result envelope

POST/integrations/connections/{connection}/actions/{action}

Requires integration.write.
Only error code unknown_action maps to 404; not_connected and unknown_connector both come back as 502. The action's declared input_schema is NOT validated by the API.

Path parameters

Name	Type	Required	Notes
`connection`	string	yes	The connection ID
`action`	string	yes

Request body

Field	Type	Required	Notes
`input`	string[] \| null	—

cURLJavaScriptPHPPython

bash

curl -X POST "$CALLAGENT_API_URL/integrations/connections/01JQ0000000000000000000000/actions/createEvent" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections/01JQ0000000000000000000000/actions/createEvent`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections/01JQ0000000000000000000000/actions/createEvent');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.post(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections/01JQ0000000000000000000000/actions/createEvent",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	JSON object

Errors

Status	When it happens
`403`	The presenting API key does not carry the integration.write scope
`404`	The connection does not exist, or the connector does not declare that action
`422`	`input` was sent but is not an array
`502`	The connector failed, is not registered, or the connection is not in a connected state

Example response, generated from the schema:

json

"string"

Pull remote records from the connector into CallAgent and return the sync result

POST/integrations/connections/{connection}/sync

Requires integration.write.
Effectively a stub for all but one connector: only McpConnector overrides sync, so every other connection returns 502 with error code not_implemented.

Path parameters

Name	Type	Required	Notes
`connection`	string	yes	The connection ID

cURLJavaScriptPHPPython

bash

curl -X POST "$CALLAGENT_API_URL/integrations/connections/01JQ0000000000000000000000/sync" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections/01JQ0000000000000000000000/sync`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections/01JQ0000000000000000000000/sync');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.post(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections/01JQ0000000000000000000000/sync",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	JSON object

Errors

Status	When it happens
`403`	The presenting API key does not carry the integration.write scope
`404`	No such connection in this organization
`502`	The connector failed, is not registered, or does not implement sync

Example response, generated from the schema:

json

"string"

Make a cheap read-only call through the connection to prove the stored credential still works

POST/integrations/connections/{connection}/test

Requires integration.write.
A failing test is HTTP 502 with ok:false, and it also writes last_tested_at, last_test_status and status back onto the connection.

Path parameters

Name	Type	Required	Notes
`connection`	string	yes	The connection ID

cURLJavaScriptPHPPython

bash

curl -X POST "$CALLAGENT_API_URL/integrations/connections/01JQ0000000000000000000000/test" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/connections/01JQ0000000000000000000000/test`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/connections/01JQ0000000000000000000000/test');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.post(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/connections/01JQ0000000000000000000000/test",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	JSON object

Errors

Status	When it happens
`403`	The presenting API key does not carry the integration.write scope
`404`	No such connection in this organization
`502`	The connector rejected the credential, failed, or is not registered

Example response, generated from the schema:

json

"string"

List the connector actions this organization's connected integrations expose to assistants as tools

GET/integrations/tools

No scope is enforced in the handler — any valid key may call it.
Only connections in a connected state and connectors with exposesTools() contribute; tool names are <slug>_<action>.

cURLJavaScriptPHPPython

bash

curl -X GET "$CALLAGENT_API_URL/integrations/tools" \
  -H "Authorization: Bearer $CALLAGENT_API_KEY" \
  -H "Accept: application/json"

const response = await fetch(`${process.env.CALLAGENT_API_URL}/integrations/tools`, {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${process.env.CALLAGENT_API_KEY}`,
    Accept: 'application/json',
  },
});

if (!response.ok) {
  const { error } = await response.json();
  throw new Error(`${error.type}: ${error.message}`);
}

const { data } = await response.json();

php

<?php

$handle = curl_init(getenv('CALLAGENT_API_URL') . '/integrations/tools');

curl_setopt_array($handle, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('CALLAGENT_API_KEY'),
        'Accept: application/json',
    ],
]);

$body = json_decode(curl_exec($handle), true);
$status = curl_getinfo($handle, CURLINFO_HTTP_CODE);
curl_close($handle);

if ($status >= 400) {
    throw new RuntimeException("{$body['error']['type']}: {$body['error']['message']}");
}

$data = $body['data'];

python

import os, requests

response = requests.get(
    f"{os.environ['CALLAGENT_API_URL']}/integrations/tools",
    headers={"Authorization": f"Bearer {os.environ['CALLAGENT_API_KEY']}"},
    timeout=30,
)
response.raise_for_status()
data = response.json()["data"]

Responses

Status	Body
`200`	`data`-wrapped array

Example response, generated from the schema:

json

{
  "data": [
    {
      "name": "Support Line",
      "description": "string",
      "input_schema": "string",
      "connection_id": "01JQ0000000000000000000000",
      "action": "string",
      "mutating": "string"
    }
  ]
}

Integrations ​

Endpoints ​

The connect gallery: connectable integrations by category, with this org's connections ​

One catalogue entry, including its declared action schemas ​

List this organization's integration connections ​

Connect an integration, encrypting any supplied secrets into a credential row, and return the connection ​

Retrieve one integration connection; secrets live in the credential row and are not returned ​

Disconnect an integration: revoke the OAuth grant, wipe and delete the credential, drop the connection ​

Run one of the connector's declared actions and return the connector's result envelope ​

Pull remote records from the connector into CallAgent and return the sync result ​

Make a cheap read-only call through the connection to prove the stored credential still works ​

List the connector actions this organization's connected integrations expose to assistants as tools ​

Integrations

Endpoints

The connect gallery: connectable integrations by category, with this org's connections

One catalogue entry, including its declared action schemas

List this organization's integration connections

Connect an integration, encrypting any supplied secrets into a credential row, and return the connection

Retrieve one integration connection; secrets live in the credential row and are not returned

Disconnect an integration: revoke the OAuth grant, wipe and delete the credential, drop the connection

Run one of the connector's declared actions and return the connector's result envelope

Pull remote records from the connector into CallAgent and return the sync result

Make a cheap read-only call through the connection to prove the stored credential still works

List the connector actions this organization's connected integrations expose to assistants as tools