Every snippet here has been run.

npm install @octokit/rest@22.0.1

import { Octokit } from "@octokit/rest";

const octokit = new Octokit({
  baseUrl: "https://gh.sandboxapis.dev",   // the only line that changes
  auth: "any-token",                       // any token is accepted
});

const { data: repo } = await octokit.repos.get({
  owner: "olympus-labs",
  repo: "parthenon",
});
const { data: prs } = await octokit.pulls.list({
  owner: "olympus-labs",
  repo: "parthenon",
  state: "closed",
  per_page: 5,
});

console.log(repo.full_name, "-", repo.description);
console.log(prs.length, "closed PRs, newest: #" + prs[0].number, prs[0].title);

brew install gh   # or see cli.github.com

export GH_HOST=gh.sandboxapis.dev
export GH_ENTERPRISE_TOKEN=any-token
export GH_CONFIG_DIR=$(mktemp -d)   # keep this out of your real gh config

gh repo view olympus-labs/parthenon \
  --json nameWithOwner,description \
  --template '{{.nameWithOwner}} - {{.description}}{{"\n"}}'

gh pr list --repo olympus-labs/parthenon --state merged --limit 3

pip install python-gitlab==6.5.0

import gitlab

gl = gitlab.Gitlab(
    "https://gl.sandboxapis.dev",   # the only line that changes
    private_token="any-token",      # any token is accepted
)

project = gl.projects.get("olympus-labs/parthenon")
mrs = project.mergerequests.list(state="merged", per_page=5, get_all=False)

print(project.path_with_namespace, "-", project.description)
print(len(mrs), "merged MRs, newest:", mrs[0].title)

npm install @gitbeaker/rest@43.8.0

import { Gitlab } from "@gitbeaker/rest";

const api = new Gitlab({
  host: "https://gl.sandboxapis.dev",   // the only line that changes
  token: "any-token",                   // any token is accepted
});

const project = await api.Projects.show("olympus-labs/parthenon");
const mrs = await api.MergeRequests.all({
  projectId: project.id,
  state: "merged",
  perPage: 5,
  maxPages: 1,
});

console.log(project.path_with_namespace, "-", project.description);
console.log(mrs.length, "merged MRs, newest:", mrs[0].title);

pip install atlassian-python-api==5.0.4

from atlassian.bitbucket import Cloud

bb = Cloud(
    url="https://bb.sandboxapis.dev",   # the only line that changes
    username="you@example.com",
    password="any-token",               # any app password is accepted
)

repo = bb.workspaces.get("olympus-labs").repositories.get("parthenon")
prs = [pr.title for pr in repo.pullrequests.each()]

print(repo.get_data("full_name"), "on", repo.get_data("mainbranch")["name"])
print(len(prs), "open PRs, newest:", prs[0])

npm install azure-devops-node-api@17.0.0

import * as azdev from "azure-devops-node-api";

const connection = new azdev.WebApi(
  "https://ado.sandboxapis.dev/olympus-labs",   // the organization URL
  azdev.getPersonalAccessTokenHandler("any-token"),
);

const core = await connection.getCoreApi();
const projects = await core.getProjects();
console.log("projects:", projects.map((p) => p.name).join(", "));

const git = await connection.getGitApi();
const repos = await git.getRepositories("olympus-labs");
console.log("repos:", repos.map((r) => r.name).sort().join(", "));

pip install azure-devops==7.1.0b4

from azure.devops.connection import Connection
from msrest.authentication import BasicAuthentication

connection = Connection(
    base_url="https://ado.sandboxapis.dev/olympus-labs",   # the organization URL
    creds=BasicAuthentication("", "any-token"),            # any PAT is accepted
)

core = connection.clients.get_core_client()
projects = core.get_projects()
print("projects:", ", ".join(sorted(p.name for p in projects)))

git = connection.clients.get_git_client()
repos = git.get_repositories("olympus-labs")
print("repos:", ", ".join(sorted(r.name for r in repos)))

pip install requests==2.32.5

import requests

org = "https://ado.sandboxapis.dev/olympus-labs"   # the organization URL

s = requests.Session()
s.auth = ("", "any-token")            # any PAT is accepted
s.params = {"api-version": "7.1"}

repos = s.get(f"{org}/_apis/git/repositories").json()
repo = repos["value"][0]["name"]

prs = s.get(
    f"{org}/olympus-labs/_apis/git/repositories/{repo}/pullrequests",
    params={"searchCriteria.status": "completed"},
).json()

print(repos["count"], "repos:", repo)
print(prs["count"], "completed PRs, newest:", prs["value"][0]["title"])

pip install jira==3.8.0

from jira import JIRA

jira = JIRA(
    server="https://jira.sandboxapis.dev",              # the only line that changes
    basic_auth=("you@example.com", "any-token"),        # any pair is accepted
)

argo = jira.project("ARGO")
boards = jira.boards(projectKeyOrID="ARGO")

print(argo.key, "-", argo.name)
print(len(boards), "board:", boards[0].name, "/ id", boards[0].id)

# nothing to install — Node 22 has fetch

const api = async (query, variables) => {
  const res = await fetch("https://linear.sandboxapis.dev/graphql", {
    method: "POST",
    headers: { "content-type": "application/json", authorization: "any-token" },
    body: JSON.stringify({ query, variables }),
  });
  const { data, errors } = await res.json();
  if (!res.ok || errors) throw new Error(res.status + " " + JSON.stringify(errors));
  return data;
};

const { teams } = await api("{ teams(first: 10) { nodes { key name } } }");
const { issues } = await api(
  `query($key: String!) {
     issues(filter: { team: { key: { eq: $key } } }, first: 3) {
       nodes { identifier title state { name } }
     }
   }`,
  { key: "ARGO" },
);

console.log("teams:", teams.nodes.map((t) => t.key + " " + t.name).join(", "));
for (const i of issues.nodes) console.log(i.identifier, i.title, "[" + i.state.name + "]");

pip install google-genai==2.32.0

from google import genai

client = genai.Client(
    api_key="any-token",                                          # any key is accepted
    http_options={"base_url": "https://antigravity.sandboxapis.dev"},  # the only line that changes
)

triggers = client.triggers.list().triggers
print("triggers:", ", ".join(t.display_name for t in triggers))

executions = client.triggers.list_executions(trigger_id=triggers[0].id).trigger_executions
run = next(e for e in executions if e.interaction_id)
interaction = client.interactions.get(id=run.interaction_id)
print("interaction", interaction.id, interaction.status, len(interaction.steps or []), "steps")

pip install prometheus-api-client==0.7.2

from prometheus_api_client import PrometheusConnect

prom = PrometheusConnect(
    url="https://prom.sandboxapis.dev",           # the only line that changes
    headers={"Authorization": "Bearer any-token"},  # any token is accepted
    disable_ssl=False,
)

names = prom.all_metrics()
print("metrics:", ", ".join(sorted(n for n in names if n.startswith("http_"))))

p99 = prom.custom_query('http_request_duration_seconds{quantile="0.99"}')
print("p99 by service:", ", ".join(sorted(r["metric"]["service"] for r in p99)))

# nothing to install: Node 22 has fetch

const grafana = "https://grafana.sandboxapis.dev";   // the only line that changes
const headers = {
  authorization: "Bearer any-token",                 // any token is accepted
  "content-type": "application/json",
};

const boards = await (await fetch(`${grafana}/api/search?type=dash-db`, { headers })).json();
console.log("dashboards:", boards.map((b) => b.uid).sort().join(", "));

const res = await fetch(`${grafana}/api/ds/query`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    queries: [{ refId: "A", datasource: { uid: "prometheus" }, expr: "service:http_request_errors:ratio" }],
    from: "now-24h",
    to: "now",
  }),
});
const { results } = await res.json();
const services = results.A.frames.map((f) => f.schema.fields[1].labels.service);
console.log("error ratio frames:", services.sort().join(", "));

pip install datadog-api-client==2.62.0

import time
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.monitors_api import MonitorsApi
from datadog_api_client.v1.api.metrics_api import MetricsApi

config = Configuration(host="https://api.dd.sandboxapis.dev")   # the only line that changes (DD_SITE is checked against Datadog's own sites)
config.api_key["apiKeyAuth"] = "any-token"                       # any key is accepted
config.api_key["appKeyAuth"] = "any-token"

with ApiClient(config) as client:
    monitors = MonitorsApi(client).list_monitors()
    print(len(monitors), "monitors, services:", ", ".join(sorted({t for m in monitors for t in m.tags if t.startswith("service:")})))
    now = int(time.time())
    q = MetricsApi(client).query_metrics(_from=now - 86400, to=now, query="avg:trace.http.request.hits{*} by {service}")
    print("series:", ", ".join(sorted(s.scope for s in q.series)))