To hold modifier keys (such as Shift, Ctrl, or Alt) while performing click or scroll actions, use the `text` parameter on those actions. This is different from `hold_key`, which holds a key for a duration without performing other actions. Shift+click (for example, to select a range of items): ```json { "action": "left_click", "coordinate": [500, 300], "text": "shift" } ``` Ctrl+click (for example, to multi-select on Windows/Linux): ```json { "action": "left_click", "coordinate": [500, 300], "text": "ctrl" } ``` Cmd+click (for example, to multi-select on macOS): ```json { "action": "left_click", "coordinate": [500, 300], "text": "super" } ``` Shift+scroll (for example, to scroll horizontally): ```json { "action": "scroll", "coordinate": [500, 400], "scroll_direction": "down", "scroll_amount": 3, "text": "shift" } ``` The `text` parameter in click/scroll actions accepts modifier keys such as `shift`, `ctrl`, `alt`, and `super` (for the Command/Windows key).

Some applications need time to respond to actions: This is application-side helper code with no API request. See the SDK tabs for the pattern. This is application-side helper code with no API request. See the SDK tabs for the pattern. ```python hidelines={1..4,-3..} import time def click_at(x, y): ... def click_and_wait(x, y, wait_time=0.5): click_at(x, y) time.sleep(wait_time) # Allow UI to update print("ok") ``` ```typescript hidelines={1..4,-3..} import { setTimeout } from "node:timers/promises"; function clickAt(x: number, y: number): void {} async function clickAndWait(x: number, y: number, waitMs = 500): Promise { clickAt(x, y); await setTimeout(waitMs); // Allow UI to update } await clickAndWait(100, 200); console.log("ok"); ``` ```csharp hidelines={1..5} ClickAndWait(100, 200); Console.WriteLine("ok"); static void ClickAt(int x, int y) { } static void ClickAndWait(int x, int y, double waitSeconds = 0.5) { ClickAt(x, y); Thread.Sleep(TimeSpan.FromSeconds(waitSeconds)); // Allow UI to update } ``` ```go hidelines={1..9,-4..} package main import ( "fmt" "time" ) func clickAt(x, y int) {} func clickAndWaitFor(x, y int, wait time.Duration) { clickAt(x, y) time.Sleep(wait) // Allow UI to update } func clickAndWait(x, y int) { clickAndWaitFor(x, y, 500*time.Millisecond) } func main() { fmt.Println("ok") } ``` ```java hidelines={1..2,-4..} void clickAt(int x, int y) {} void clickAndWait(int x, int y) throws InterruptedException { clickAndWait(x, y, 500); } void clickAndWait(int x, int y, long waitTimeMillis) throws InterruptedException { clickAt(x, y); Thread.sleep(waitTimeMillis); // Allow UI to update } void main() { IO.println("ok"); } ``` ```php hidelines={1..4,-2..} ```ruby hidelines={1..2,-2..} def click_at(x, y) = nil def click_and_wait(x, y, wait_time: 0.5) click_at(x, y) sleep(wait_time) # Allow UI to update end puts "ok" ```

Check that requested actions are safe and valid: This is application-side helper code with no API request. See the SDK tabs for the pattern. This is application-side helper code with no API request. See the SDK tabs for the pattern. ```python hidelines={1,-3..} display_width, display_height = 1024, 768 def validate_action(action_type, params): if action_type == "left_click": x, y = params.get("coordinate", (0, 0)) if not (0 <= x < display_width and 0 <= y < display_height): return False, "Coordinates out of bounds" return True, None print(validate_action("left_click", {"coordinate": (2000, 100)})) ``` ```typescript hidelines={1..3,-2..} const displayWidth = 1024; const displayHeight = 768; interface ActionParams { coordinate?: [number, number]; } function validateAction(actionType: string, params: ActionParams): [boolean, string | null] { if (actionType === "left_click") { const [x, y] = params.coordinate ?? [0, 0]; if (!(x >= 0 && x < displayWidth && y >= 0 && y < displayHeight)) { return [false, "Coordinates out of bounds"]; } } return [true, null]; } console.log(validateAction("left_click", { coordinate: [2000, 100] })); ``` ```csharp hidelines={1..2,5..7} using System.Text.Json; const int DisplayWidth = 1024; const int DisplayHeight = 768; Console.WriteLine(ValidateAction("left_click", new Dictionary { ["coordinate"] = JsonSerializer.SerializeToElement(new[] { 2000, 100 }) })); static (bool IsValid, string? Error) ValidateAction(string actionType, IReadOnlyDictionary parameters) { if (actionType == "left_click") { int x = parameters["coordinate"][0].GetInt32(); int y = parameters["coordinate"][1].GetInt32(); if (x is < 0 or >= DisplayWidth || y is < 0 or >= DisplayHeight) { return (false, "Coordinates out of bounds"); } } return (true, null); } ``` ```go hidelines={1..4,-5..} package main import "fmt" const ( displayWidth = 1024 displayHeight = 768 ) func validateAction(actionType string, params map[string]any) (bool, string) { if actionType == "left_click" { coord, ok := params["coordinate"].([]any) if !ok || len(coord) != 2 { return false, "Invalid coordinate" } x, y := int(coord[0].(float64)), int(coord[1].(float64)) if !(0 <= x && x < displayWidth && 0 <= y && y < displayHeight) { return false, "Coordinates out of bounds" } } return true, "" } func main() { ok, msg := validateAction("left_click", map[string]any{"coordinate": []any{2000.0, 100.0}}) fmt.Println(ok, msg) } ``` ```java hidelines={1..2,-4..} import com.anthropic.core.JsonValue; static final int DISPLAY_WIDTH = 1024; static final int DISPLAY_HEIGHT = 768; record Validation(boolean valid, String error) {} Validation validateAction(String actionType, Map params) { if (actionType.equals("left_click")) { List coord = (List) params.get("coordinate").asArray().get(); long x = ((Number) coord.get(0).asNumber().get()).longValue(); long y = ((Number) coord.get(1).asNumber().get()).longValue(); if (!(0 <= x && x < DISPLAY_WIDTH && 0 <= y && y < DISPLAY_HEIGHT)) { return new Validation(false, "Coordinates out of bounds"); } } return new Validation(true, null); } void main() { IO.println(validateAction("left_click", Map.of("coordinate", JsonValue.from(List.of(2000, 100))))); } ``` ```php hidelines={1..2,-3..} [2000, 100]]); echo ($valid ? 'true' : 'false') . ' ' . $error . "\n"; ``` ```ruby hidelines={-2..} DISPLAY_WIDTH = 1024 DISPLAY_HEIGHT = 768 def validate_action(action_type, params) if action_type == "left_click" x, y = params.fetch(:coordinate, [0, 0]) unless (0...DISPLAY_WIDTH).cover?(x) && (0...DISPLAY_HEIGHT).cover?(y) return [false, "Coordinates out of bounds"] end end [true, nil] end p validate_action("left_click", {coordinate: [2000, 100]}) ```

Keep a log of all actions for troubleshooting: This is application-side helper code with no API request. See the SDK tabs for the pattern. This is application-side helper code with no API request. See the SDK tabs for the pattern. ```python hidelines={-3..} import logging def log_action(action_type, params, result): logging.info(f"Action: {action_type}, Params: {params}, Result: {result}") print("ok") ``` ```typescript hidelines={-2..} function logAction(actionType: string, params: unknown, result: unknown): void { console.error( `Action: ${actionType}, Params: ${JSON.stringify(params)}, Result: ${JSON.stringify( result )}` ); } console.log("ok"); ``` ```csharp hidelines={1..3} LogAction("screenshot", null, ""); Console.WriteLine("ok"); static void LogAction(string actionType, object? parameters, object? result) { Console.Error.WriteLine($"Action: {actionType}, Params: {parameters}, Result: {result}"); } ``` ```go hidelines={1..7,-4..} package main import ( "fmt" "log" ) func logAction(actionType string, params map[string]any, result any) { log.Printf("Action: %s, Params: %v, Result: %v", actionType, params, result) } func main() { fmt.Println("ok") } ``` ```java hidelines={-4..} import static java.lang.System.Logger.Level.INFO; static final System.Logger LOGGER = System.getLogger("computer-use"); void logAction(String actionType, Object params, Object result) { LOGGER.log(INFO, "Action: {0}, Params: {1}, Result: {2}", actionType, params, result); } void main() { IO.println("ok"); } ``` ```php hidelines={1..2,-2..} ```ruby hidelines={-2..} require "logger" LOGGER = Logger.new($stderr) def log_action(action_type, params, result) LOGGER.info("Action: #{action_type}, Params: #{params}, Result: #{result}") end puts "ok" ```