API Reference

curl https://your-testhide-server/api/v3/healthz

import requests

r = requests.get("https://your-testhide-server/api/v3/healthz")
print(r.json())

{"status": "ok", "version": "3.14.2", "build": "a1b2c3d"}

curl -X POST https://your-testhide-server/api/v3/authenticate \
  -H "Content-Type: application/json" \
  -d '{"username": "[email protected]", "password": "s3cr3t!"}'

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/authenticate",
    json={"username": "[email protected]", "password": "s3cr3t!"}
)
token = r.json()["token"]
print(token)

{"token": "eyJhbGci...", "expires_at": "2026-05-21T14:00:00Z", "user_id": 42}

curl -X POST https://your-testhide-server/api/v3/logout \
  -H "Authorization: Bearer $TOKEN"

import requests

requests.post(
    "https://your-testhide-server/api/v3/logout",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)

(no content)

curl https://your-testhide-server/api/v3/me \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/me",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"id": 42, "email": "[email protected]", "role": "admin", "projects": [1, 3, 7]}

curl https://your-testhide-server/api/v3/config \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/config",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"version": "3.14.2", "global_options": {"ai_assist": {"enabled": true}, "max_parallel_builds": 20}}

curl -X POST https://your-testhide-server/api/v3/sso \
  -H "Content-Type: application/json" \
  -d '{"saml_response": "PHNhbWxwOlJlc3BvbnNl..."}'

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/sso",
    json={"saml_response": "PHNhbWxwOlJlc3BvbnNl..."}
)
print(r.json()["token"])

{"token": "eyJhbGci...", "user_id": 42, "expires_at": "2026-05-21T14:00:00Z"}

curl -X POST https://your-testhide-server/api/v3/reset-password \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}'

import requests

requests.post(
    "https://your-testhide-server/api/v3/reset-password",
    json={"email": "[email protected]"}
)

{"detail": "Reset link sent if the account exists."}

curl -X POST https://your-testhide-server/api/v3/reset-password/confirm \
  -H "Content-Type: application/json" \
  -d '{"token": "abc123xyz", "new_password": "Str0ng!Pass"}'

import requests

requests.post(
    "https://your-testhide-server/api/v3/reset-password/confirm",
    json={"token": "abc123xyz", "new_password": "Str0ng!Pass"}
)

{"detail": "Password updated successfully."}

curl https://your-testhide-server/api/v3/api-tokens \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/api-tokens",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

[{"id": 1, "name": "CI Bot", "created_at": "2026-01-10T09:00:00Z", "last_used": "2026-05-19T12:30:00Z"}]

curl -X POST https://your-testhide-server/api/v3/api-tokens \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "GitHub Actions Bot"}'

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/api-tokens",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"name": "GitHub Actions Bot"}
)
secret = r.json()["secret"]  # save this — shown only once

{"id": 5, "name": "GitHub Actions Bot", "secret": "th_live_xK9p...Q2rZ", "created_at": "2026-05-20T10:00:00Z"}

curl -X DELETE https://your-testhide-server/api/v3/api-tokens/5 \
  -H "Authorization: Bearer $TOKEN"

import requests

requests.delete(
    "https://your-testhide-server/api/v3/api-tokens/5",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)

(no content)

curl "https://your-testhide-server/api/v3/users?page=1&limit=20" \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/users",
    params={"page": 1, "limit": 20},
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"total": 84, "results": [{"id": 1, "email": "[email protected]", "role": "admin", "active": true}]}

curl -X POST https://your-testhide-server/api/v3/users \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]", "role": "developer", "project_ids": [1, 3]}'

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/users",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"email": "[email protected]", "role": "developer", "project_ids": [1, 3]}
)
print(r.json()["id"])

{"id": 88, "email": "[email protected]", "role": "developer", "invited_at": "2026-05-20T10:00:00Z"}

curl https://your-testhide-server/api/v3/users/88 \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/users/88",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"id": 88, "email": "[email protected]", "role": "developer", "active": true, "projects": [1, 3], "last_login": "2026-05-19T08:00:00Z"}

curl -X PUT https://your-testhide-server/api/v3/users/88 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"role": "admin", "project_ids": [1, 3, 7]}'

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/users/88",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"role": "admin", "project_ids": [1, 3, 7]}
)
print(r.json())

{"id": 88, "email": "[email protected]", "role": "admin", "project_ids": [1, 3, 7]}

curl https://your-testhide-server/api/v3/users/88/permissions \
  -H "Authorization: Bearer $TOKEN"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/users/88/permissions",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"user_id": 88, "can_start_builds": true, "can_manage_nodes": false, "is_admin": false, "projects": {"1": "write", "3": "read"}}

curl https://your-testhide-server/api/v3/projects \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/projects", headers={"Authorization": "Bearer YOUR_TOKEN"})
for p in r.json(): print(p["id"], p["name"])

[{"id": 1, "name": "Backend API", "slug": "backend-api", "jobs_count": 12}]

curl -X POST https://your-testhide-server/api/v3/projects \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "Mobile App", "description": "iOS/Android tests", "scm_endpoint_id": 2}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/projects",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"name": "Mobile App", "description": "iOS/Android tests", "scm_endpoint_id": 2}
)
print(r.json()["id"])

{"id": 12, "name": "Mobile App", "slug": "mobile-app", "webhook_secret": "wh_sec_abc..."}

curl https://your-testhide-server/api/v3/projects/12 \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/projects/12", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"id": 12, "name": "Mobile App", "jobs_count": 8, "last_build_at": "2026-05-19T18:00:00Z", "webhook_url": "https://your-testhide-server/webhook/proj/12"}

curl -X PUT https://your-testhide-server/api/v3/projects/12 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "Mobile App v2", "scm_endpoint_id": 3}'

import requests
r = requests.put("https://your-testhide-server/api/v3/projects/12", headers={"Authorization": "Bearer YOUR_TOKEN"}, json={"name": "Mobile App v2", "scm_endpoint_id": 3})
print(r.json())

{"id": 12, "name": "Mobile App v2", "scm_endpoint_id": 3}

curl -X POST https://your-testhide-server/api/v3/projects/12/rotate-webhook-secret \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.post("https://your-testhide-server/api/v3/projects/12/rotate-webhook-secret", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json()["webhook_secret"])

{"webhook_secret": "wh_sec_xK9p...Q2rZ"}

curl "https://your-testhide-server/api/v3/jobs?project_id=1&enabled=true" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/jobs", params={"project_id": 1, "enabled": "true"}, headers={"Authorization": "Bearer YOUR_TOKEN"})
for job in r.json(): print(job["id"], job["name"])

[{"id": 55, "name": "Regression Suite", "project_id": 1, "node_pool_id": 2, "enabled": true}]

curl -X POST https://your-testhide-server/api/v3/jobs \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Smoke Tests",
    "project_id": 1,
    "node_pool_id": 2,
    "timeout_minutes": 30,
    "max_parallel": 3
  }'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/jobs",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"name": "Smoke Tests", "project_id": 1, "node_pool_id": 2, "timeout_minutes": 30, "max_parallel": 3}
)
print(r.json()["id"])

{"id": 56, "name": "Smoke Tests", "project_id": 1, "enabled": true}

curl https://your-testhide-server/api/v3/jobs/55 \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/jobs/55", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"id": 55, "name": "Regression Suite", "node_pool_id": 2, "last_build_id": 1024, "last_build_status": "passed"}

curl -X PUT https://your-testhide-server/api/v3/jobs/55 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"enabled": false, "timeout_minutes": 90}'

import requests
r = requests.put("https://your-testhide-server/api/v3/jobs/55", headers={"Authorization": "Bearer YOUR_TOKEN"}, json={"enabled": False, "timeout_minutes": 90})
print(r.json())

{"id": 55, "enabled": false, "timeout_minutes": 90}

curl -X DELETE https://your-testhide-server/api/v3/jobs/55 \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.delete("https://your-testhide-server/api/v3/jobs/55", headers={"Authorization": "Bearer YOUR_TOKEN"})

(no content)

curl https://your-testhide-server/api/v3/jobs/55/configuration \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/jobs/55/configuration", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"setup": ["pip install -r requirements.txt"], "command": "pytest tests/ -x", "env": {"ENV": "staging"}, "artifacts": ["reports/*.xml"]}

curl -X PUT https://your-testhide-server/api/v3/jobs/55/configuration \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "setup": ["pip install -r requirements.txt"],
    "command": "pytest tests/ --junitxml=report.xml",
    "env": {"ENV": "staging", "DB_HOST": "db.internal"},
    "artifacts": ["report.xml", "logs/*.log"]
  }'

import requests
r = requests.put(
    "https://your-testhide-server/api/v3/jobs/55/configuration",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={
        "setup": ["pip install -r requirements.txt"],
        "command": "pytest tests/ --junitxml=report.xml",
        "env": {"ENV": "staging", "DB_HOST": "db.internal"},
        "artifacts": ["report.xml", "logs/*.log"]
    }
)
print(r.status_code)

{"job_id": 55, "updated_at": "2026-05-20T10:15:00Z"}

curl -X POST https://your-testhide-server/api/v3/jobs/55/export \
  -H "Authorization: Bearer $TOKEN" \
  -o job_55_export.json

import requests, json
r = requests.post("https://your-testhide-server/api/v3/jobs/55/export", headers={"Authorization": "Bearer YOUR_TOKEN"})
with open("job_55_export.json", "w") as f:
    json.dump(r.json(), f, indent=2)

{"export_version": "1", "job": {"name": "Regression Suite", ...}, "configuration": {...}}

curl -X POST https://your-testhide-server/api/v3/jobs/import \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"project_id": 3, "bundle": {...}}'

import requests, json
bundle = json.load(open("job_55_export.json"))
r = requests.post(
    "https://your-testhide-server/api/v3/jobs/import",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"project_id": 3, "bundle": bundle}
)
print("New job ID:", r.json()["id"])

{"id": 99, "name": "Regression Suite (imported)", "project_id": 3}

curl -X POST https://your-testhide-server/api/v3/builds/start \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "job_id": 55,
    "branch": "main",
    "commit_sha": "a1b2c3d4",
    "env": {"RUN_SLOW": "true"}
  }'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/builds/start",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"job_id": 55, "branch": "main", "commit_sha": "a1b2c3d4", "env": {"RUN_SLOW": "true"}}
)
build_id = r.json()["id"]
print("Build started:", build_id)

{"id": 1025, "job_id": 55, "status": "queued", "branch": "main", "commit_sha": "a1b2c3d4", "created_at": "2026-05-20T10:00:00Z"}

curl "https://your-testhide-server/api/v3/builds?job_id=55&status=failed&limit=10" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get(
    "https://your-testhide-server/api/v3/builds",
    params={"job_id": 55, "status": "failed", "limit": 10},
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(r.json())

{"total": 3, "results": [{"id": 1024, "status": "failed", "branch": "main", "duration_s": 312, "failed_tests": 7}]}

curl https://your-testhide-server/api/v3/builds/1024 \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/builds/1024", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"id": 1024, "job_id": 55, "status": "passed", "duration_s": 287, "total_tests": 412, "passed": 410, "failed": 0, "skipped": 2, "node_id": 7}

curl -X POST https://your-testhide-server/api/v3/builds/1024/restart \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"failed_only": true}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/builds/1024/restart",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"failed_only": True}
)
print("New build ID:", r.json()["id"])

{"id": 1026, "status": "queued", "restarted_from": 1024}

curl -X POST https://your-testhide-server/api/v3/builds/1025/stop \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.post("https://your-testhide-server/api/v3/builds/1025/stop", headers={"Authorization": "Bearer YOUR_TOKEN"})

{"id": 1025, "status": "aborted"}

curl -X DELETE https://your-testhide-server/api/v3/builds/1020 \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.delete("https://your-testhide-server/api/v3/builds/1020", headers={"Authorization": "Bearer YOUR_TOKEN"})

(no content)

curl -X POST https://your-testhide-server/api/v3/builds/1025/push_to_top \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.post("https://your-testhide-server/api/v3/builds/1025/push_to_top", headers={"Authorization": "Bearer YOUR_TOKEN"})

{"id": 1025, "queue_position": 1}

curl -X POST https://your-testhide-server/api/v3/builds/1024/keep-forever \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.post("https://your-testhide-server/api/v3/builds/1024/keep-forever", headers={"Authorization": "Bearer YOUR_TOKEN"})

{"id": 1024, "keep_forever": true}

curl "https://your-testhide-server/api/v3/builds/1024/pipeline_logs?offset=0&limit=200" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get(
    "https://your-testhide-server/api/v3/builds/1024/pipeline_logs",
    params={"offset": 0, "limit": 200},
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
for line in r.json()["lines"]: print(line)

{"total_lines": 1240, "lines": ["[10:00:01] Setup started", "[10:00:03] pip install OK", "..."]}

curl -N https://your-testhide-server/api/v3/builds/1025/stream \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: text/event-stream"

import requests

with requests.get(
    "https://your-testhide-server/api/v3/builds/1025/stream",
    headers={"Authorization": "Bearer YOUR_TOKEN", "Accept": "text/event-stream"},
    stream=True
) as r:
    for line in r.iter_lines():
        if line:
            print(line.decode())

data: {"type": "log", "data": "[10:00:05] PASSED tests/test_api.py::test_login"}
data: {"type": "status", "data": "passed"}
data: {"type": "done"}

curl -X POST https://your-testhide-server/api/v3/builds/1024/comment \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"text": "Flaky DB connection — infra issue, not code."}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/builds/1024/comment",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"text": "Flaky DB connection — infra issue, not code."}
)
print(r.json())

{"id": 88, "build_id": 1024, "text": "Flaky DB connection...", "author": "[email protected]"}

curl -X POST https://your-testhide-server/api/v3/builds/1024/retry-flaky \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.post("https://your-testhide-server/api/v3/builds/1024/retry-flaky", headers={"Authorization": "Bearer YOUR_TOKEN"})
print("New build:", r.json()["id"], "| Retrying", r.json()["test_count"], "tests")

{"id": 1027, "status": "queued", "test_count": 4, "restarted_from": 1024}

curl -X POST https://your-testhide-server/api/v3/builds/git-notify \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "project_id": 1,
    "branch": "feature/login-fix",
    "commit_sha": "d4e5f6a7",
    "author": "[email protected]",
    "message": "Fix auth token refresh"
  }'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/builds/git-notify",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"project_id": 1, "branch": "feature/login-fix", "commit_sha": "d4e5f6a7", "author": "[email protected]"}
)
print("Builds queued:", r.json()["queued"])

{"queued": 2, "build_ids": [1028, 1029]}

curl "https://your-testhide-server/api/v3/artifacts?build_id=1024" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/artifacts", params={"build_id": 1024}, headers={"Authorization": "Bearer YOUR_TOKEN"})
for a in r.json(): print(a["name"], a["size_bytes"])

[{"id": 201, "name": "report.xml", "type": "report", "size_bytes": 48200, "created_at": "2026-05-20T10:05:00Z"}]

curl "https://your-testhide-server/api/v3/artifacts/tree?build_id=1024" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/artifacts/tree", params={"build_id": 1024}, headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"name": "/", "children": [{"name": "reports", "children": [{"name": "report.xml", "id": 201}]}, {"name": "logs", "children": []}]}

curl -X POST https://your-testhide-server/api/v3/artifacts/upload \
  -H "Authorization: Bearer $TOKEN" \
  -F "build_id=1024" \
  -F "path=reports/" \
  -F "[email protected]"

import requests
with open("report.xml", "rb") as f:
    r = requests.post(
        "https://your-testhide-server/api/v3/artifacts/upload",
        headers={"Authorization": "Bearer YOUR_TOKEN"},
        data={"build_id": 1024, "path": "reports/"},
        files={"file": ("report.xml", f, "application/xml")}
    )
print(r.json()["id"])

{"id": 202, "name": "report.xml", "size_bytes": 48200, "path": "reports/report.xml"}

curl -X DELETE https://your-testhide-server/api/v3/artifacts/201 \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.delete("https://your-testhide-server/api/v3/artifacts/201", headers={"Authorization": "Bearer YOUR_TOKEN"})

(no content)

curl https://your-testhide-server/api/v3/artifacts/201/download \
  -H "Authorization: Bearer $TOKEN" \
  -o report.xml

import requests
r = requests.get("https://your-testhide-server/api/v3/artifacts/201/download", headers={"Authorization": "Bearer YOUR_TOKEN"})
with open("report.xml", "wb") as f:
    f.write(r.content)

(binary file content with Content-Type matching the artifact)

curl https://your-testhide-server/api/v3/report/1024 \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/report/1024", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"build_id": 1024, "total": 412, "passed": 400, "failed": 7, "skipped": 5, "duration_s": 287, "suites": [{"name": "auth", "passed": 45, "failed": 1}]}

curl "https://your-testhide-server/api/v3/tests?build_id=1024&status=failed" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/tests", params={"build_id": 1024, "status": "failed"}, headers={"Authorization": "Bearer YOUR_TOKEN"})
for t in r.json()["results"]: print(t["node_id"], t["message"])

{"total": 7, "results": [{"id": 5001, "node_id": "tests/test_auth.py::test_token_refresh", "status": "failed", "duration_ms": 1230, "message": "AssertionError: Expected 200, got 401"}]}

curl "https://your-testhide-server/api/v3/tests/5001/history?limit=10" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/tests/5001/history", params={"limit": 10}, headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"node_id": "tests/test_auth.py::test_token_refresh", "history": [{"build_id": 1024, "status": "failed"}, {"build_id": 1023, "status": "passed"}, {"build_id": 1022, "status": "failed"}]}

curl -X POST https://your-testhide-server/api/v3/tests/5001/classification \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"classification": "product_bug"}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/tests/5001/classification",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"classification": "product_bug"}
)
print(r.json())

{"test_id": 5001, "classification": "product_bug", "set_by": "[email protected]"}

curl -X POST https://your-testhide-server/api/v3/tests/5001/defect \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"defect_key": "AUTH-421", "defect_url": "https://jira.corp.com/browse/AUTH-421"}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/tests/5001/defect",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"defect_key": "AUTH-421", "defect_url": "https://jira.corp.com/browse/AUTH-421"}
)
print(r.json())

{"test_id": 5001, "defect_key": "AUTH-421", "defect_url": "https://jira.corp.com/browse/AUTH-421"}

curl -X POST https://your-testhide-server/api/v3/tests/5001/resolution \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"resolution": "Fixed in PR #847 — token expiry now handles edge case."}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/tests/5001/resolution",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"resolution": "Fixed in PR #847 — token expiry now handles edge case."}
)
print(r.json())

{"test_id": 5001, "resolution": "Fixed in PR #847...", "set_by": "[email protected]"}

curl -X POST https://your-testhide-server/api/v3/tests/5001/known-issue \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"known_issue_id": 17}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/tests/5001/known-issue",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"known_issue_id": 17}
)
print(r.json())

{"test_id": 5001, "known_issue_id": 17, "auto_classify_future": true}

curl "https://your-testhide-server/api/v3/quarantine?job_id=55" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/quarantine", params={"job_id": 55}, headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

[{"id": 1, "node_id": "tests/test_auth.py::test_token_refresh", "reason": "flaky", "quarantined_at": "2026-05-10T09:00:00Z"}]

curl -X POST https://your-testhide-server/api/v3/quarantine \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"job_id": 55, "node_id": "tests/test_auth.py::test_token_refresh", "reason": "flaky"}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/quarantine",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"job_id": 55, "node_id": "tests/test_auth.py::test_token_refresh", "reason": "flaky"}
)
print(r.json()["id"])

{"id": 2, "node_id": "tests/test_auth.py::test_token_refresh", "reason": "flaky"}

curl -X POST https://your-testhide-server/api/v3/quarantine/bulk \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"job_id": 55, "action": "add", "node_ids": ["tests/test_a.py::test_x", "tests/test_b.py::test_y"]}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/quarantine/bulk",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"job_id": 55, "action": "add", "node_ids": ["tests/test_a.py::test_x", "tests/test_b.py::test_y"]}
)
print(r.json())

{"added": 2, "skipped": 0}

curl "https://your-testhide-server/api/v3/quarantine/stats?job_id=55" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/quarantine/stats", params={"job_id": 55}, headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"total": 14, "by_reason": {"flaky": 9, "infra": 3, "wip": 2}, "oldest_days": 42}

curl "https://your-testhide-server/api/v3/quarantine/nodeids?job_id=55" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/quarantine/nodeids", params={"job_id": 55}, headers={"Authorization": "Bearer YOUR_TOKEN"})
node_ids = r.json()["node_ids"]
deselect_args = " ".join(f"--deselect={n}" for n in node_ids)
print(deselect_args)

{"node_ids": ["tests/test_auth.py::test_token_refresh", "tests/test_db.py::test_conn_pool"]}

curl https://your-testhide-server/api/v3/pipeline-templates \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/pipeline-templates", headers={"Authorization": "Bearer YOUR_TOKEN"})
for t in r.json(): print(t["id"], t["name"])

[{"id": 3, "name": "Python pytest", "description": "Standard Python test pipeline", "jobs_using": 12}]

curl -X POST https://your-testhide-server/api/v3/pipeline-templates \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Node.js Jest",
    "setup": ["npm ci"],
    "env": {"NODE_ENV": "test"},
    "artifacts": ["coverage/**", "test-results/*.xml"]
  }'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/pipeline-templates",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"name": "Node.js Jest", "setup": ["npm ci"], "env": {"NODE_ENV": "test"}, "artifacts": ["coverage/**"]}
)
print(r.json()["id"])

{"id": 4, "name": "Node.js Jest", "jobs_using": 0}

curl -X PUT https://your-testhide-server/api/v3/pipeline-templates/4 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"setup": ["npm ci", "npx playwright install --with-deps"]}'

import requests
r = requests.put("https://your-testhide-server/api/v3/pipeline-templates/4", headers={"Authorization": "Bearer YOUR_TOKEN"}, json={"setup": ["npm ci", "npx playwright install --with-deps"]})
print(r.json())

{"id": 4, "name": "Node.js Jest", "updated_at": "2026-05-20T11:00:00Z"}

curl -X DELETE https://your-testhide-server/api/v3/pipeline-templates/4 \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.delete("https://your-testhide-server/api/v3/pipeline-templates/4", headers={"Authorization": "Bearer YOUR_TOKEN"})

(no content)

curl "https://your-testhide-server/api/v3/nodes?status=online" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/nodes", params={"status": "online"}, headers={"Authorization": "Bearer YOUR_TOKEN"})
for n in r.json(): print(n["name"], n["status"])

[{"id": 7, "name": "agent-01", "status": "online", "pool_id": 2, "running_builds": 1, "cpu_pct": 62}]

curl -X POST https://your-testhide-server/api/v3/nodes \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "agent-05", "pool_id": 2, "tags": ["linux", "docker"], "max_parallel": 2}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/nodes",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"name": "agent-05", "pool_id": 2, "tags": ["linux", "docker"], "max_parallel": 2}
)
agent_token = r.json()["agent_token"]
print("Agent token:", agent_token)  # configure agent with this

{"id": 12, "name": "agent-05", "pool_id": 2, "agent_token": "agt_xK9p...Q2rZ"}

curl "https://your-testhide-server/api/v3/nodes/find?name=agent-05" \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/nodes/find", params={"name": "agent-05"}, headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"id": 12, "name": "agent-05", "status": "online", "pool_id": 2}

curl https://your-testhide-server/api/v3/nodes/12 \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/nodes/12", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"id": 12, "name": "agent-05", "status": "online", "cpu_cores": 8, "ram_gb": 16, "uptime_s": 86400, "running_builds": 1}

curl -X PUT https://your-testhide-server/api/v3/nodes/12 \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pool_id": 3, "max_parallel": 4}'

import requests
r = requests.put("https://your-testhide-server/api/v3/nodes/12", headers={"Authorization": "Bearer YOUR_TOKEN"}, json={"pool_id": 3, "max_parallel": 4})
print(r.json())

{"id": 12, "pool_id": 3, "max_parallel": 4}

curl -X DELETE https://your-testhide-server/api/v3/nodes/12 \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.delete("https://your-testhide-server/api/v3/nodes/12", headers={"Authorization": "Bearer YOUR_TOKEN"})

(no content)

curl -X POST https://your-testhide-server/api/v3/nodes/12/quarantine \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.post("https://your-testhide-server/api/v3/nodes/12/quarantine", headers={"Authorization": "Bearer YOUR_TOKEN"})

{"id": 12, "status": "quarantined"}

curl https://your-testhide-server/api/v3/nodes/12/health \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/nodes/12/health", headers={"Authorization": "Bearer YOUR_TOKEN"})
print(r.json())

{"node_id": 12, "cpu_pct": 62, "ram_pct": 48, "disk_free_gb": 120, "last_heartbeat_s": 4}

curl -X POST https://your-testhide-server/api/v3/nodes/12/restart \
  -H "Authorization: Bearer $TOKEN"

import requests
requests.post("https://your-testhide-server/api/v3/nodes/12/restart", headers={"Authorization": "Bearer YOUR_TOKEN"})

{"detail": "Restart command sent to node 12."}

curl -X POST https://your-testhide-server/api/v3/nodes/12/execute \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"command": "df -h /", "timeout_s": 10}'

import requests
r = requests.post(
    "https://your-testhide-server/api/v3/nodes/12/execute",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"command": "df -h /", "timeout_s": 10}
)
print(r.json()["stdout"])

{"exit_code": 0, "stdout": "Filesystem  Size  Used Avail Use%\n/dev/sda1   500G  380G  120G  76%", "stderr": ""}

curl https://your-testhide-server/api/v3/nodes/agent/latest \
  -H "Authorization: Bearer $TOKEN"

import requests
r = requests.get("https://your-testhide-server/api/v3/nodes/agent/latest", headers={"Authorization": "Bearer YOUR_TOKEN"})
linux = r.json()["linux_amd64"]
print("Download:", linux["url"])

{"version": "3.14.2", "linux_amd64": {"url": "https://your-server/agent/3.14.2/linux-amd64", "sha256": "abc123..."}, "windows_amd64": {"url": "...", "sha256": "..."}}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/node-pools

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/node-pools",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 3, "name": "linux-large", "project_id": 12,
  "node_count": 8, "labels": {"arch": "amd64", "size": "large"}}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"linux-large","project_id":12,"labels":{"arch":"amd64","size":"large"},"max_parallel":10}' \
  https://your-testhide-server/api/v3/node-pools

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/node-pools",
    headers={"Authorization": "Bearer TOKEN"},
    json={"name": "linux-large", "project_id": 12,
          "labels": {"arch": "amd64", "size": "large"}, "max_parallel": 10}
)
print(r.json())

{"id": 3, "name": "linux-large", "project_id": 12, "max_parallel": 10,
  "labels": {"arch": "amd64", "size": "large"}, "node_count": 0}

curl -X PUT \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"max_parallel":20,"labels":{"arch":"amd64","size":"xlarge"}}' \
  https://your-testhide-server/api/v3/node-pools/3

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/node-pools/3",
    headers={"Authorization": "Bearer TOKEN"},
    json={"max_parallel": 20, "labels": {"arch": "amd64", "size": "xlarge"}}
)
print(r.json())

{"id": 3, "name": "linux-large", "max_parallel": 20,
  "labels": {"arch": "amd64", "size": "xlarge"}, "node_count": 8}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/node-pools/3

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/node-pools/3",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/docker-agents?status=running"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/docker-agents",
    headers={"Authorization": "Bearer TOKEN"},
    params={"status": "running"}
)
print(r.json())

[{"id": "da-7f3c", "host": "build-host-01", "image": "testhide/agent:3.14",
  "status": "running", "build_id": 9812, "started_at": "2025-06-10T08:12:00Z"}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"host":"build-host-01","image":"testhide/agent:3.14","pool_id":3,"cpus":4.0,"memory_mb":8192}' \
  https://your-testhide-server/api/v3/docker-agents/spawn

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/docker-agents/spawn",
    headers={"Authorization": "Bearer TOKEN"},
    json={"host": "build-host-01", "image": "testhide/agent:3.14",
          "pool_id": 3, "cpus": 4.0, "memory_mb": 8192}
)
print(r.json())

{"id": "da-9a1e", "host": "build-host-01", "status": "starting",
  "image": "testhide/agent:3.14", "pool_id": 3}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/docker-agents/da-7f3c/start

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/docker-agents/da-7f3c/start",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"id": "da-7f3c", "status": "running"}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/docker-agents/da-7f3c/stop

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/docker-agents/da-7f3c/stop",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"id": "da-7f3c", "status": "stopped"}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/docker-agents/da-7f3c

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/docker-agents/da-7f3c",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/docker-agents/da-7f3c/logs?tail=100"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/docker-agents/da-7f3c/logs",
    headers={"Authorization": "Bearer TOKEN"},
    params={"tail": 100}
)
print(r.json())

{"lines": ["[08:12:01] Agent started", "[08:12:02] Connected to server",
  "[08:12:05] Picked up build 9812"]}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/webhooks

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/webhooks",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 14, "url": "https://hooks.example.com/testhide",
  "events": ["build.finished","build.failed"], "active": true,
  "deliveries_ok": 312, "deliveries_failed": 2}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://hooks.example.com/testhide","events":["build.finished","build.failed"],"secret":"s3cr3t"}' \
  https://your-testhide-server/api/v3/webhooks

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/webhooks",
    headers={"Authorization": "Bearer TOKEN"},
    json={"url": "https://hooks.example.com/testhide",
          "events": ["build.finished", "build.failed"],
          "secret": "s3cr3t"}
)
print(r.json())

{"id": 14, "url": "https://hooks.example.com/testhide",
  "events": ["build.finished","build.failed"], "active": true}

curl -X PUT \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"active":false}' \
  https://your-testhide-server/api/v3/webhooks/14

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/webhooks/14",
    headers={"Authorization": "Bearer TOKEN"},
    json={"active": False}
)
print(r.json())

{"id": 14, "active": false, "events": ["build.finished","build.failed"]}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/webhooks/14

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/webhooks/14",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/webhooks/14/test

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/webhooks/14/test",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"delivered": true, "status_code": 200, "latency_ms": 142}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/webhooks/14/history?limit=20&status=failed"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/webhooks/14/history",
    headers={"Authorization": "Bearer TOKEN"},
    params={"limit": 20, "status": "failed"}
)
print(r.json())

[{"delivery_id": "d-882f", "event": "build.failed", "status_code": 503,
  "error": "connection refused", "attempted_at": "2025-06-10T07:55:12Z"}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ids":[14,15,16]}' \
  https://your-testhide-server/api/v3/webhooks/bulk-delete

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/webhooks/bulk-delete",
    headers={"Authorization": "Bearer TOKEN"},
    json={"ids": [14, 15, 16]}
)
print(r.json())

{"deleted": 3, "ids": [14, 15, 16]}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ms-teams

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ms-teams",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 5, "name": "CI Alerts", "project_id": 12,
  "webhook_url": "https://outlook.office.com/webhook/...",
  "events": ["build.failed","test.flaky"], "active": true}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"CI Alerts","webhook_url":"https://outlook.office.com/webhook/xxx","project_id":12,"events":["build.failed","test.flaky"]}' \
  https://your-testhide-server/api/v3/ms-teams

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ms-teams",
    headers={"Authorization": "Bearer TOKEN"},
    json={"name": "CI Alerts",
          "webhook_url": "https://outlook.office.com/webhook/xxx",
          "project_id": 12,
          "events": ["build.failed", "test.flaky"]}
)
print(r.json())

{"id": 5, "name": "CI Alerts", "active": true,
  "events": ["build.failed","test.flaky"]}

curl -X PUT \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"events":["build.failed","build.finished","test.flaky"],"active":true}' \
  https://your-testhide-server/api/v3/ms-teams/5

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/ms-teams/5",
    headers={"Authorization": "Bearer TOKEN"},
    json={"events": ["build.failed", "build.finished", "test.flaky"], "active": True}
)
print(r.json())

{"id": 5, "active": true, "events": ["build.failed","build.finished","test.flaky"]}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ms-teams/5

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/ms-teams/5",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ms-teams/5/test

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ms-teams/5/test",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"sent": true, "status_code": 200, "latency_ms": 198}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/scm

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/scm",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 2, "type": "github", "host": "github.com",
  "name": "Main GitHub", "project_id": 12, "repo": "acme/backend"}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type":"github","name":"Main GitHub","project_id":12,"repo":"acme/backend","token":"ghp_xxxxx"}' \
  https://your-testhide-server/api/v3/scm

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/scm",
    headers={"Authorization": "Bearer TOKEN"},
    json={"type": "github", "name": "Main GitHub",
          "project_id": 12, "repo": "acme/backend", "token": "ghp_xxxxx"}
)
print(r.json())

{"id": 2, "type": "github", "name": "Main GitHub",
  "repo": "acme/backend", "project_id": 12}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/scm/2

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/scm/2",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"id": 2, "type": "github", "host": "github.com",
  "name": "Main GitHub", "repo": "acme/backend", "project_id": 12}

curl -X PUT \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"token":"ghp_newtoken_yyyy"}' \
  https://your-testhide-server/api/v3/scm/2

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/scm/2",
    headers={"Authorization": "Bearer TOKEN"},
    json={"token": "ghp_newtoken_yyyy"}
)
print(r.json())

{"id": 2, "type": "github", "repo": "acme/backend", "updated": true}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/scm/2

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/scm/2",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/scm/2/branches?q=release"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/scm/2/branches",
    headers={"Authorization": "Bearer TOKEN"},
    params={"q": "release"}
)
print(r.json())

["release/3.14", "release/3.13", "release/3.12"]

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/scm/2/commits?branch=main&limit=5"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/scm/2/commits",
    headers={"Authorization": "Bearer TOKEN"},
    params={"branch": "main", "limit": 5}
)
print(r.json())

[{"sha": "a1b2c3d", "message": "Fix race condition in worker pool",
  "author": "alice", "date": "2025-06-10T09:30:00Z"}]

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/vcenter

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/vcenter",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 1, "name": "Prod vCenter", "host": "vcenter.corp.local",
  "datacenter": "DC-East", "connected": true}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"Prod vCenter","host":"vcenter.corp.local","username":"svc-testhide","password":"s3cr3t","datacenter":"DC-East"}' \
  https://your-testhide-server/api/v3/vcenter

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/vcenter",
    headers={"Authorization": "Bearer TOKEN"},
    json={"name": "Prod vCenter", "host": "vcenter.corp.local",
          "username": "svc-testhide", "password": "s3cr3t",
          "datacenter": "DC-East"}
)
print(r.json())

{"id": 1, "name": "Prod vCenter", "host": "vcenter.corp.local",
  "datacenter": "DC-East", "connected": true}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/vcenter/1

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/vcenter/1",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"id": 1, "name": "Prod vCenter", "host": "vcenter.corp.local",
  "datacenter": "DC-East", "cluster": "Compute-01", "connected": true}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/vcenter/1/test

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/vcenter/1/test",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"connected": true, "vcenter_version": "8.0.2", "latency_ms": 45}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/vcenter/1/sync

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/vcenter/1/sync",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"synced_vms": 24, "updated": 3, "duration_ms": 1840}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"vm_id":"vm-1042","action":"power_on"}' \
  https://your-testhide-server/api/v3/vcenter/1/vm/power

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/vcenter/1/vm/power",
    headers={"Authorization": "Bearer TOKEN"},
    json={"vm_id": "vm-1042", "action": "power_on"}
)
print(r.json())

{"vm_id": "vm-1042", "action": "power_on", "status": "powered_on"}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"project_id":12,"branch":"main","dry_run":false}' \
  https://your-testhide-server/api/v3/gitops/sync

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/gitops/sync",
    headers={"Authorization": "Bearer TOKEN"},
    json={"project_id": 12, "branch": "main", "dry_run": False}
)
print(r.json())

{"synced": true, "project_id": 12, "branch": "main",
  "sha": "a1b2c3d", "jobs_updated": 4, "jobs_created": 1, "jobs_removed": 0}

# Simulating a GitHub push event
curl -X POST \
  -H "X-Hub-Signature-256: sha256=abc123..." \
  -H "Content-Type: application/json" \
  -d '{"ref":"refs/heads/main","repository":{"full_name":"acme/backend"}}' \
  https://your-testhide-server/api/v3/gitops/webhook

import requests, hmac, hashlib, json

payload = {"ref": "refs/heads/main",
           "repository": {"full_name": "acme/backend"}}
body = json.dumps(payload).encode()
sig = "sha256=" + hmac.new(b"webhook-secret", body, hashlib.sha256).hexdigest()

r = requests.post(
    "https://your-testhide-server/api/v3/gitops/webhook",
    headers={"X-Hub-Signature-256": sig,
             "Content-Type": "application/json"},
    data=body
)
print(r.json())

{"accepted": true, "project_id": 12, "branch": "main", "sync_queued": true}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/jira

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/jira",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": 3, "name": "ACME Jira", "host": "https://acme.atlassian.net",
  "project_key": "BACK", "auto_create": true}]

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"ACME Jira","host":"https://acme.atlassian.net","email":"[email protected]","api_token":"ATATT...","project_key":"BACK","auto_create":true}' \
  https://your-testhide-server/api/v3/jira

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/jira",
    headers={"Authorization": "Bearer TOKEN"},
    json={"name": "ACME Jira", "host": "https://acme.atlassian.net",
          "email": "[email protected]", "api_token": "ATATT...",
          "project_key": "BACK", "auto_create": True}
)
print(r.json())

{"id": 3, "name": "ACME Jira", "project_key": "BACK",
  "auto_create": true, "host": "https://acme.atlassian.net"}

curl -X PUT \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"auto_create":false,"project_key":"QA"}' \
  https://your-testhide-server/api/v3/jira/3

import requests

r = requests.put(
    "https://your-testhide-server/api/v3/jira/3",
    headers={"Authorization": "Bearer TOKEN"},
    json={"auto_create": False, "project_key": "QA"}
)
print(r.json())

{"id": 3, "project_key": "QA", "auto_create": false}

curl -X DELETE \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/jira/3

import requests

r = requests.delete(
    "https://your-testhide-server/api/v3/jira/3",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.status_code)  # 204

— No content —

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message":"Why did this build fail?","build_id":9812}' \
  https://your-testhide-server/api/v3/ai/chat

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ai/chat",
    headers={"Authorization": "Bearer TOKEN"},
    json={"message": "Why did this build fail?", "build_id": 9812}
)
print(r.json())

{"session_id": "sess-a8f3", "reply": "Build 9812 failed in stage 'unit-tests'. The test...",
  "sources": ["build:9812", "test:47821"]}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{"message":"Summarize this build","build_id":9812}' \
  --no-buffer \
  https://your-testhide-server/api/v3/ai/chat/stream

import requests

with requests.post(
    "https://your-testhide-server/api/v3/ai/chat/stream",
    headers={"Authorization": "Bearer TOKEN",
             "Accept": "text/event-stream"},
    json={"message": "Summarize this build", "build_id": 9812},
    stream=True
) as r:
    for line in r.iter_lines():
        if line:
            print(line.decode())

data: {"token": "Build"}
data: {"token": " 9812"}
data: {"token": " failed"}
data: [DONE]

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ai/llm/status

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/llm/status",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"provider": "openai", "model": "gpt-4o", "available": true,
  "features": ["chat", "investigation", "test_health"]}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ai/quota

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/quota",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"tokens_used": 142800, "tokens_limit": 1000000,
  "resets_at": "2025-07-01T00:00:00Z", "percent_used": 14.3}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"build_id":9812,"include_logs":true}' \
  https://your-testhide-server/api/v3/ai/diagnose

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ai/diagnose",
    headers={"Authorization": "Bearer TOKEN"},
    json={"build_id": 9812, "include_logs": True}
)
print(r.json())

{"build_id": 9812, "root_cause": "OOM in test worker",
  "confidence": 0.87, "suggested_fix": "Increase JVM heap size or reduce parallelism",
  "affected_tests": 14}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/insights?project_id=12&days=14"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/insights",
    headers={"Authorization": "Bearer TOKEN"},
    params={"project_id": 12, "days": 14}
)
print(r.json())

{"project_id": 12, "period_days": 14, "build_pass_rate": 0.82,
  "top_flaky_tests": [{"test": "UserLoginTest", "flake_rate": 0.34}],
  "failure_patterns": ["Database connection timeout on CI network"]}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ai/summary/9812

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/summary/9812",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"build_id": 9812, "summary": "Build 9812 ran 1,240 tests, 14 failed. Most failures cluster around database timeout errors in the payment module. 3 tests appear flaky based on history."}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type":"project_audit","project_id":12}' \
  https://your-testhide-server/api/v3/ai/job/stream

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ai/job/stream",
    headers={"Authorization": "Bearer TOKEN"},
    json={"type": "project_audit", "project_id": 12}
)
print(r.json())

{"job_id": "aijob-f2c8", "status": "queued", "estimated_seconds": 45}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ai/job/aijob-f2c8/result

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/job/aijob-f2c8/result",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"job_id": "aijob-f2c8", "status": "complete",
  "result": {"audit_score": 74, "recommendations": ["Quarantine 8 chronic flakes", "..."]}}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/ai/job/aijob-f2c8/cancel

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/ai/job/aijob-f2c8/cancel",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"job_id": "aijob-f2c8", "status": "cancelled"}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/search?q=database+timeout&project_id=12"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/search",
    headers={"Authorization": "Bearer TOKEN"},
    params={"q": "database timeout", "project_id": 12}
)
print(r.json())

{"results": [{"type": "build", "id": 9812, "score": 0.94,
  "snippet": "...connection to postgres timed out after 30s..."}]}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/tests/health?project_id=12&days=14"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/tests/health",
    headers={"Authorization": "Bearer TOKEN"},
    params={"project_id": 12, "days": 14}
)
print(r.json())

{"tests": [{"test_id": 47821, "name": "UserLoginTest",
  "health_score": 32, "flake_rate": 0.34, "trend": "worsening",
  "risk": "high", "recommended_action": "quarantine"}]}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/tests/47821/health?days=30"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/tests/47821/health",
    headers={"Authorization": "Bearer TOKEN"},
    params={"days": 30}
)
print(r.json())

{"test_id": 47821, "health_score": 32, "flake_rate": 0.34,
  "failure_patterns": ["Race condition on login session", "Timeout on slow CI"],
  "correlated_builds": [9800, 9790, 9781],
  "recommendation": "Add explicit wait or quarantine until fixed"}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/emerging/latest?project_id=12"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/emerging/latest",
    headers={"Authorization": "Bearer TOKEN"},
    params={"project_id": 12}
)
print(r.json())

{"emerging": [{"test_id": 52004, "name": "PaymentFlowTest",
  "baseline_rate": 0.02, "recent_rate": 0.18, "delta": 0.16,
  "first_seen_build": 9808}]}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/ai/emerging/history?project_id=12&days=30"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/ai/emerging/history",
    headers={"Authorization": "Bearer TOKEN"},
    params={"project_id": 12, "days": 30}
)
print(r.json())

[{"detected_at": "2025-06-05T10:00:00Z", "test_id": 52004,
  "name": "PaymentFlowTest", "delta": 0.16, "resolved": false},
 {"detected_at": "2025-05-28T08:00:00Z", "test_id": 48120,
  "name": "CacheWarmupTest", "delta": 0.22, "resolved": true}]

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/evals

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/evals",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

[{"id": "eval-c3d9", "model": "gpt-4o", "status": "complete",
  "score": 0.89, "cases_total": 100, "cases_passed": 89,
  "created_at": "2025-06-10T07:00:00Z"}]

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/evals/eval-c3d9

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/evals/eval-c3d9",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"id": "eval-c3d9", "model": "gpt-4o", "score": 0.89,
  "cases_total": 100, "cases_passed": 89, "cases_failed": 11,
  "failures": [{"case": "diagnose_oom", "expected": "OOM", "got": "timeout"}],
  "duration_s": 142}

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"suite":"diagnosis","model_override":"gpt-4o-mini","sample_size":50}' \
  https://your-testhide-server/api/v3/evals/runs

import requests

r = requests.post(
    "https://your-testhide-server/api/v3/evals/runs",
    headers={"Authorization": "Bearer TOKEN"},
    json={"suite": "diagnosis", "model_override": "gpt-4o-mini", "sample_size": 50}
)
print(r.json())

{"id": "eval-d7a1", "status": "pending", "suite": "diagnosis",
  "model": "gpt-4o-mini", "estimated_s": 90}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/evals/regressions?baseline_id=eval-c3d9¤t_id=eval-d7a1"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/evals/regressions",
    headers={"Authorization": "Bearer TOKEN"},
    params={"baseline_id": "eval-c3d9", "current_id": "eval-d7a1"}
)
print(r.json())

{"baseline": "eval-c3d9", "current": "eval-d7a1",
  "score_delta": -0.06, "regressions": [
    {"case": "diagnose_oom", "baseline": "pass", "current": "fail"}
  ], "improvements": []}

curl -H "Authorization: Bearer $TOKEN" \
  "https://your-testhide-server/api/v3/search?q=payment+timeout&types=build,test&project_id=12"

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/search",
    headers={"Authorization": "Bearer TOKEN"},
    params={"q": "payment timeout", "types": "build,test", "project_id": 12}
)
print(r.json())

{"query": "payment timeout", "results": [
  {"type": "test", "id": 52004, "name": "PaymentFlowTest",
   "snippet": "...timed out waiting for payment gateway response...", "score": 0.97},
  {"type": "build", "id": 9812,
   "snippet": "...14 tests failed: payment gateway timeout...", "score": 0.91}
]}

curl -H "Authorization: Bearer $TOKEN" \
  https://your-testhide-server/api/v3/license/status

import requests

r = requests.get(
    "https://your-testhide-server/api/v3/license/status",
    headers={"Authorization": "Bearer TOKEN"}
)
print(r.json())

{"tier": "enterprise", "valid": true,
  "expires_at": "2026-12-31T23:59:59Z",
  "seats_licensed": 100, "seats_used": 42,
  "capabilities": {
    "ai_chat": true,
    "ai_test_health": true,
    "llm_evals": true,
    "white_label": true,
    "vcenter": true,
    "sso": true,
    "max_users": 100
  }}