Home Chrome Browser
Home / Chrome Browser / Get Text

Get Text

POST
/tools-api/chrome/get-text

Description

Retrieves the complete text content of the current page in the Chrome browser. This endpoint extracts all visible text from the browser's current tab, which can be useful for analyzing page content, extracting information, or performing text-based searches.

This action is more efficient than manually parsing through the DOM when you only need the visible text content of a page.

Request Format

This endpoint does not require any specific parameters in the request body. It operates on the currently active Chrome browser tab. 

{
    // No parameters required
}
Note: The Chrome browser must be open and have at least one active tab for this endpoint to work correctly.

Response Format

The endpoint returns a response object with the following properties:

Property Type Description
success boolean Indicates whether the operation was successful
message string The complete text content extracted from the current page
timestamp string (ISO date) The time when the operation was performed

Example Response

{
    "success": true,
    "message": "Welcome to Example Website\nHome About Services Contact\nLorem ipsum dolor sit amet, consectetur adipiscing elit...\n[All visible text from the page]",
    "timestamp": "2023-09-15T14:30:22.123Z"
}

Code Examples

import requests
import json

# Set your API key and base URL
api_key = "your_api_key_here"
base_url = "http://localhost:54321"

# Endpoint
url = f"{base_url}/tools-api/chrome/get-text"

# Headers
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

# Make the request
response = requests.post(url, headers=headers, json={})

# Handle the response
if response.status_code == 200:
    result = response.json()
    if result["success"]:
        page_text = result["message"]  # The extracted text is in the "message" field
        print("Page Text:", page_text)
    else:
        print(f"Error: {result['message']}")
else:
    print(f"HTTP Error: {response.status_code}")
                    
import axios from 'axios';

// Set your API key and base URL
const apiKey = 'your_api_key_here';
const baseUrl = 'http://localhost:54321';

// Function to get page text
async function getChromePageText() {
    try {
        const response = await axios.post(
            `${baseUrl}/tools-api/chrome/get-text`,
            {}, // Empty request body
            {
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${apiKey}`
                }
            }
        );
        
        const result = response.data;
        if (result.success) {
            console.log('Page Text:', result.message);  // The extracted text is in the "message" field
            return result.message;
        } else {
            console.error('Error:', result.message);
            return null;
        }
    } catch (error) {
        console.error('Request failed:', error);
        return null;
    }
}

// Usage
getChromePageText().then(text => {
    // Process the page text
    if (text) {
        // Do something with the text
        const keywords = ['contact', 'email', 'phone'];
        const containsContactInfo = keywords.some(word => 
            text.toLowerCase().includes(word)
        );
        
        console.log('Contains contact information:', containsContactInfo);
    }
});
                    
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 _baseUrl;
    private readonly string _apiKey;

    public ToolsServerClient(string baseUrl, string apiKey)
    {
        _baseUrl = baseUrl;
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _apiKey);
    }

    public async Task GetChromePageTextAsync()
    {
        var url = $"{_baseUrl}/tools-api/chrome/get-text";
        
        // Create an empty request body
        var requestContent = new StringContent("{}", Encoding.UTF8, "application/json");
        
        try
        {
            var response = await _httpClient.PostAsync(url, requestContent);
            response.EnsureSuccessStatusCode();
            
            var responseBody = await response.Content.ReadAsStringAsync();
            var result = JsonSerializer.Deserialize(responseBody);
            
            if (result.Success)
            {
                Console.WriteLine("Page text retrieved successfully");
                return result.Message;  // The extracted text is in the "Message" field
            }
            else
            {
                Console.WriteLine($"Error: {result.Message}");
                return null;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Request failed: {ex.Message}");
            return null;
        }
    }

    // Response class
    private class ChromeTextResponse
    {
        public bool Success { get; set; }
        public string Message { get; set; }
        public DateTime Timestamp { get; set; }
    }
}

// Usage example
public class Program
{
    public static async Task Main()
    {
        var client = new ToolsServerClient("http://localhost:54321", "your_api_key_here");
        var pageText = await client.GetChromePageTextAsync();
        
        if (!string.IsNullOrEmpty(pageText))
        {
            // Process the page text
            // For example, search for specific content
            bool containsPrivacyPolicy = pageText.Contains("Privacy Policy");
            Console.WriteLine($"Page contains Privacy Policy: {containsPrivacyPolicy}");
        }
    }
}

Usage Examples

Extracting Specific Information

You can use this endpoint to extract specific information from a webpage without having to parse the full DOM structure.

// After getting the page text const pageText = result.message; // Extract pricing information if (pageText.includes('Price:')) { const priceIndex = pageText.indexOf('Price:'); const priceEndIndex = pageText.indexOf('\n', priceIndex); const priceText = pageText.substring(priceIndex, priceEndIndex).trim(); console.log('Found pricing information:', priceText); } // Check if page contains contact information const hasContactInfo = pageText.includes('Contact Us') || pageText.includes('Email:') || pageText.includes('Phone:'); console.log('Page has contact information:', hasContactInfo);

Text Analysis

Perform basic text analysis on the page content.

// After getting the page text const pageText = result.message; // Count words const wordCount = pageText.split(/\s+/).filter(word => word.length > 0).length; console.log('Total words on page:', wordCount); // Find most frequent words (simple implementation) const words = pageText.toLowerCase().replace(/[^\w\s]/g, '').split(/\s+/); const wordFrequency = {}; words.forEach(word => { if (word.length > 3) { // Skip short words wordFrequency[word] = (wordFrequency[word] || 0) + 1; } }); const topWords = Object.entries(wordFrequency) .sort((a, b) => b[1] - a[1]) .slice(0, 10); console.log('Most frequent words:', topWords);

Notes and Best Practices

Note: The text extraction only includes content that would be visible to a user. Hidden elements, scripts, and CSS are excluded.

Tip: For more structured data extraction, consider using /tools-api/chrome/get-dom instead, which provides the full DOM structure.

Important: This endpoint depends on an active Chrome browser session. Ensure Chrome is open before calling this endpoint.