Documentation
Home / Chrome Browser / Reload Chrome

Reload Chrome

POST
/tools-api/chrome/reload

Reloads the current tab in the Chrome browser. This is equivalent to pressing F5 or clicking the refresh button in the browser.

Request

This endpoint does not require any specific parameters in the request body.

Request Format

{
  // No parameters required
}

Response

The response includes information about whether the action was successful and any relevant messages.

Response Fields

Field Type Description
success boolean Indicates whether the reload action was successful.
message string A message describing the result of the operation or any error that occurred.
timestamp string (ISO 8601) The timestamp when the action was executed.

Response Example

{
  "success": true,
  "message": "Chrome tab reloaded successfully",
  "timestamp": "2025-03-12T10:05:23.456Z"
}

Code Examples

import requests
import json

def reload_chrome_tab(api_url, api_key):
    """
    Reload the current Chrome tab.
    
    Args:
        api_url (str): The base URL of the Tools Server API
        api_key (str): Your API key for authentication
        
    Returns:
        dict: The response from the API
    """
    endpoint = f"{api_url}/tools-api/chrome/reload"
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    # No request body needed for this endpoint
    response = requests.post(endpoint, headers=headers, json={})
    
    return response.json()

# Example usage
if __name__ == "__main__":
    API_URL = "http://localhost:9123"
    API_KEY = "your_api_key_here"
    
    result = reload_chrome_tab(API_URL, API_KEY)
    print(json.dumps(result, indent=2))
interface ActionResponse {
  success: boolean;
  message?: string;
  timestamp: string;
}

async function reloadChromeTab(apiUrl: string, apiKey: string): Promise {
  const endpoint = `${apiUrl}/tools-api/chrome/reload`;
  
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  };
  
  // No request body needed for this endpoint
  const response = await fetch(endpoint, {
    method: 'POST',
    headers,
    body: JSON.stringify({})
  });
  
  if (!response.ok) {
    throw new Error(`HTTP error! Status: ${response.status}`);
  }
  
  return await response.json() as ActionResponse;
}

// Example usage
(async () => {
  const API_URL = 'http://localhost:9123';
  const API_KEY = 'your_api_key_here';
  
  try {
    const result = await reloadChromeTab(API_URL, API_KEY);
    console.log('Response:', 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 class ToolsServerClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    
    public ToolsServerClient(string apiUrl, string apiKey)
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri(apiUrl)
        };
        _apiKey = apiKey;
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
    }
    
    public class ActionResponse
    {
        public bool Success { get; set; }
        public string Message { get; set; }
        public DateTime Timestamp { get; set; }
    }
    
    public async Task ReloadChromeTabAsync()
    {
        // No request body needed for this endpoint
        var content = new StringContent("{}", Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync("/tools-api/chrome/reload", content);
        response.EnsureSuccessStatusCode();
        
        var responseBody = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize(responseBody, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        });
    }
}

// Example usage
class Program
{
    static async Task Main()
    {
        string apiUrl = "http://localhost:9123";
        string apiKey = "your_api_key_here";
        
        var client = new ToolsServerClient(apiUrl, apiKey);
        try
        {
            var result = await client.ReloadChromeTabAsync();
            Console.WriteLine($"Success: {result.Success}");
            Console.WriteLine($"Message: {result.Message}");
            Console.WriteLine($"Timestamp: {result.Timestamp}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Examples

Basic Usage

This endpoint is straightforward - it simply reloads the current active tab in Chrome. It's useful when you need to refresh the page to see updated content or reset the state of a web application.

Error Handling

Possible error scenarios to handle: