Exemplos v1

Gerados a partir do próprio esquema OpenAPI — nunca escritos à mão por endpoint. Cada exemplo demonstra autenticação, paginação (quando aplicável) e tratamento de erros.

GET /students 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/students?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/students?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/students?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/students?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /students/{student} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/students/{student}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/students/{student}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/students/{student}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/students/{student}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/assessments 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/assessments/{assessment} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments/{assessment}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments/{assessment}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments/{assessment}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/assessments/{assessment}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/resources 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/resources/{resource} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources/{resource}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources/{resource}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources/{resource}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/resources/{resource}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/meetings 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /courses/{course}/sessions/{session}/meetings/{meeting} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings/{meeting}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings/{meeting}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings/{meeting}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/courses/{course}/sessions/{session}/meetings/{meeting}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /users 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/users?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/users?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/users?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/users?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /users/{user} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/users/{user}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/users/{user}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/users/{user}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/users/{user}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /enrolments 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/enrolments?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/enrolments?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/enrolments?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/enrolments?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /enrolments/{enrolment} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/enrolments/{enrolment}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/enrolments/{enrolment}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/enrolments/{enrolment}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/enrolments/{enrolment}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /notifications 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/notifications?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/notifications?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/notifications?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/notifications?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /notifications/{notification} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/notifications/{notification}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/notifications/{notification}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/notifications/{notification}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/notifications/{notification}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /certificates 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/certificates?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/certificates?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/certificates?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/certificates?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /certificates/{certificate} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/certificates/{certificate}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/certificates/{certificate}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/certificates/{certificate}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/certificates/{certificate}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /certificates/verify/{certificate} 
curl \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/certificates/verify/{certificate}"
$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", ['Accept: application/json']),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/certificates/verify/{certificate}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import requests

response = requests.get('https://catdi.org/api/v1/certificates/verify/{certificate}', headers={'Accept': 'application/json'})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/certificates/verify/{certificate}', {
  headers: { Accept: 'application/json' },
});

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

const data = await response.json();
GET /documents 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/documents?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/documents?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/documents?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/documents?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /documents/{document} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/documents/{document}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/documents/{document}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/documents/{document}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/documents/{document}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /documents/{document}/download 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/documents/{document}/download"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/documents/{document}/download', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/documents/{document}/download', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/documents/{document}/download', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /reports 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/reports?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/reports?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/reports?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/reports?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /reports/{report} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/reports/{report}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/reports/{report}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/reports/{report}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/reports/{report}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /reports/{report}/download 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/reports/{report}/download"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/reports/{report}/download', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/reports/{report}/download', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/reports/{report}/download', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /search 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/search?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/search?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/search?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/search?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /organization 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/organization"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/organization', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/organization', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/organization', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /workflows 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/workflows?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/workflows?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/workflows?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/workflows?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /workflows/{workflow} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/workflows/{workflow}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/workflows/{workflow}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/workflows/{workflow}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/workflows/{workflow}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /tasks 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/tasks?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/tasks?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/tasks?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/tasks?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /tasks/{task} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/tasks/{task}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/tasks/{task}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/tasks/{task}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/tasks/{task}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /integrations 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/integrations?per_page=20"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/integrations?per_page=20', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/integrations?per_page=20', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/integrations?per_page=20', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /integrations/{message} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/integrations/{message}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/integrations/{message}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/integrations/{message}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/integrations/{message}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /health 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/health"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/health', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/health', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/health', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();
GET /health/{check} 
curl \
  -H "Authorization: Bearer $CATDI_TOKEN" \
  -H "Accept: application/json" \
  "https://catdi.org/api/v1/health/{check}"
$token = getenv('CATDI_TOKEN');

$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => implode("\r\n", [
    'Authorization: Bearer '.$token,
    'Accept: application/json',
]),
        'ignore_errors' => true, // read the body even on 4xx/5xx
    ],
]);

$response = file_get_contents('https://catdi.org/api/v1/health/{check}', false, $context);
$status = (int) explode(' ', $http_response_header[0])[1];

if ($status >= 400) {
    $error = json_decode($response, true);
    throw new RuntimeException("CATDI API error {$status}: {$error['message']}");
}

$data = json_decode($response, true);
import os
token = os.environ['CATDI_TOKEN']

import requests

response = requests.get('https://catdi.org/api/v1/health/{check}', headers={
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
})

if not response.ok:
    error = response.json()
    raise RuntimeError(f"CATDI API error {response.status_code}: {error['message']}")

data = response.json()
const response = await fetch('https://catdi.org/api/v1/health/{check}', {
  headers: {
    Authorization: `Bearer ${process.env.CATDI_TOKEN}`,
    Accept: 'application/json',
  },
});

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

const data = await response.json();