Sessions

first = client.runs.create("Open Hacker News")
client.runs.wait_for_completion(first.id)

follow_up = client.runs.create(
    "Now summarize the top story",
    session_id=first.session_id,
)
result = client.runs.wait_for_completion(follow_up.id)
print(result.result)

const first = await client.runs.create({
  task: "Open Hacker News",
  model: "gpt-5.6-luna",
  modelParams: { reasoning: { effort: "xhigh" } },
});
await client.runs.waitForCompletion(first.id);

const followUp = await client.runs.create({
  task: "Now summarize the top story",
  model: "gpt-5.6-luna",
  modelParams: { reasoning: { effort: "xhigh" } },
  sessionId: first.sessionId,
});
const result = await client.runs.waitForCompletion(followUp.id);
console.log(result.result);

run = client.runs.create("Open my dashboard", keep_alive=900)

const run = await client.runs.create({
  task: "Open my dashboard",
  keepAlive: 900,
});

curl https://api.browser-use.com/api/v4/runs \
  -H "X-Browser-Use-API-Key: $BROWSER_USE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task":"Open my dashboard","keepAlive":900}'

import time

message = client.sessions.send_message(
    first.session_id,
    "Now summarize the top story",
    interrupt=False,
)
deadline = time.monotonic() + 300
while message.run_id is None:
    if message.status.value in {"cancelled", "superseded", "failed"}:
        raise RuntimeError(f"Queued message {message.status.value}")
    remaining = deadline - time.monotonic()
    if remaining <= 0:
        raise TimeoutError(f"Message {message.id} is still waiting; keep its ID")
    time.sleep(min(1, remaining))
    message = client.sessions.get_message(first.session_id, message.id)

result = client.runs.wait_for_completion(message.run_id)
print(result.status.value, result.result)

let message = await client.sessions.sendMessage(first.sessionId, {
  text: "Now summarize the top story",
  interrupt: false,
});
const deadline = Date.now() + 300_000;
while (message.runId === null) {
  if (["cancelled", "superseded", "failed"].includes(message.status)) {
    throw new Error(`Queued message ${message.status}`);
  }
  const remaining = deadline - Date.now();
  if (remaining <= 0) {
    throw new Error(`Message ${message.id} is still waiting; keep its ID`);
  }
  await new Promise((resolve) => setTimeout(resolve, Math.min(1_000, remaining)));
  message = await client.sessions.getMessage(first.sessionId, message.id);
}

const result = await client.runs.waitForCompletion(message.runId);
console.log(result.status, result.result);