Opens Google Chrome and navigates to the specified URL. This endpoint provides options for handling situations where Chrome is already running.
Since it is not possible to start a Playwright-managed Chrome browser instance with user profile information when an existing Chrome instance already uses it, you have to provide a strategy parameter that specifies how to handle this situation.
Note: This is typically the first action you should perform before using other Chrome-related endpoints. Chrome must be opened through this endpoint for other Chrome automation actions to work correctly. After opening Chrome, it's recommended to use the Explain Current Tab endpoint to get detailed information about the page content for better interaction.
The request requires a URL to navigate to and optionally a strategy for handling existing Chrome instances.
{
"url": "string", // URL to navigate to
"strategy": "ThrowError" | "ForceClose" | "StartWithoutUserProfile" // Optional strategy
}
| Parameter | Type | Required | Description |
|---|---|---|---|
| url | string | Yes | The URL to navigate to when opening Chrome |
| strategy | enum | No |
Strategy to use when handling existing Chrome instances. Options are:
|
{
"url": "https://www.google.com",
"strategy": "ForceClose"
}The response is a simple success/failure message.
{
"success": boolean, // Whether the operation was successful
"message": "string" // Result message or error description
}
| Field | Type | Description |
|---|---|---|
| success | boolean | Indicates whether the operation was successful |
| message | string | Description of the result or error message if the operation failed |
{
"success": true,
"message": "Chrome has been opened and navigated to https://www.google.com"
}{
"success": false,
"message": "Error: Chrome is already running with the user profile. Use a different strategy or close Chrome manually."
}import requests
import json
def open_chrome(url, api_key, strategy="ThrowError"):
"""
Opens Chrome and navigates to the specified URL.
Args:
url (str): The URL to navigate to
api_key (str): Your API key for authentication
strategy (str): Strategy to handle existing Chrome instances
("ThrowError", "ForceClose", or "StartWithoutUserProfile")
Returns:
dict: The response from the server
"""
endpoint = "http://localhost:9950/tools-api/system/open-chrome"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}
data = {
"url": url,
"strategy": strategy
}
response = requests.post(endpoint, headers=headers, data=json.dumps(data))
return response.json()
# Example usage
api_key = "your_api_key_here"
result = open_chrome("https://www.example.com", api_key, "ForceClose")
print(result)
interface OpenChromeRequest {
url: string;
strategy?: "ThrowError" | "ForceClose" | "StartWithoutUserProfile";
}
interface SimpleResponse {
success: boolean;
message: string;
}
/**
* Opens Chrome and navigates to the specified URL
* @param url The URL to navigate to
* @param apiKey Your API key for authentication
* @param strategy Strategy to handle existing Chrome instances
* @returns Promise with the response
*/
async function openChrome(
url: string,
apiKey: string,
strategy: "ThrowError" | "ForceClose" | "StartWithoutUserProfile" = "ThrowError"
): Promise {
const endpoint = "http://localhost:9950/tools-api/system/open-chrome";
const response = await fetch(endpoint, {
method: "POST",
headers: {
"Content-Type": "application/json",
"Authorization": `Bearer ${apiKey}`
},
body: JSON.stringify({
url,
strategy
} as OpenChromeRequest)
});
return await response.json() as SimpleResponse;
}
// Example usage
const apiKey = "your_api_key_here";
openChrome("https://www.example.com", apiKey, "ForceClose")
.then(result => console.log(result))
.catch(error => console.error("Error:", error));
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public enum ExistingChromeInstanceStrategy
{
ThrowError,
ForceClose,
StartWithoutUserProfile
}
public class OpenChromeRequest
{
public string Url { get; set; }
public ExistingChromeInstanceStrategy Strategy { get; set; } = ExistingChromeInstanceStrategy.ThrowError;
}
public class SimpleResponse
{
public bool Success { get; set; }
public string Message { get; set; }
}
public class ToolsServerClient
{
private readonly HttpClient _httpClient;
private readonly string _apiKey;
public ToolsServerClient(string apiKey)
{
_httpClient = new HttpClient();
_httpClient.BaseAddress = new Uri("http://localhost:9950/");
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
_apiKey = apiKey;
}
public async Task OpenChromeAsync(
string url,
ExistingChromeInstanceStrategy strategy = ExistingChromeInstanceStrategy.ThrowError)
{
var request = new OpenChromeRequest
{
Url = url,
Strategy = strategy
};
var content = new StringContent(
JsonSerializer.Serialize(request),
Encoding.UTF8,
"application/json");
var response = await _httpClient.PostAsync("tools-api/system/open-chrome", content);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize(responseString);
}
}
// Example usage
class Program
{
static async Task Main()
{
var client = new ToolsServerClient("your_api_key_here");
var result = await client.OpenChromeAsync(
"https://www.example.com",
ExistingChromeInstanceStrategy.ForceClose);
Console.WriteLine($"Success: {result.Success}, Message: {result.Message}");
}
}