Cách thực hiện các truy vấn theo lô trên ChatGPT cho GEO: Giải pháp tự động sử dụng Scrapeless Cloud Browser

npm install puppeteer-core @scrapeless-ai/sdk node-fetch

import puppeteer, { Browser, Page } from 'puppeteer-core';
import { Scrapeless, PuppeteerLaunchOptions } from '@scrapeless-ai/sdk';

const scrapeless = new Scrapeless();

async function connectBrowser(): Promise<Browser> {
  const options: PuppeteerLaunchOptions = {
    session_name: 'Batch ChatGPT',
    session_ttl: 600,
    fingerprint: {
      platform: 'macOS',
      localization: { timezone: 'America/New_York' },
      args: { '--window-size': '1920,1080' },
    },
  };

  const { browserWSEndpoint } = await scrapeless.browser.createSession(options);
  const browser = await puppeteer.connect({ browserWSEndpoint, defaultViewport: null });
  return browser;
}

async function queryChatGPT(browser: Browser, prompt: string): Promise<string> {
  const page = await browser.newPage();
  await page.goto('https://chatgpt.com/');

  const inputSelector = '[placeholder="Ask anything"]';
  await page.waitForSelector(inputSelector, { visible: true });
  await page.type(inputSelector, prompt);
  await page.keyboard.press('Enter');

  await page.waitForSelector('[data-message-author-role="assistant"]');
  const result = await page.evaluate(() => {
    const messages = document.querySelectorAll('[data-message-author-role="assistant"]');
    return messages[messages.length - 1]?.textContent || '';
  });

  await page.close();
  return result;
}

let gptAnswer: string;
gptAnswer = await waitForChatGPTResponse(page);

let gptImageCards: ChatgptResponse['image_cards'] = [];
// Sử dụng các bộ chọn để trích xuất hình ảnh và xây dựng { url, vị trí }

const gptRecommendProducts: ChatgptResponse['products'] = [];
// Sử dụng các bộ chọn để trích xuất liên kết sản phẩm, tiêu đề và hình ảnh

let gptCitations: ChatgptResponse['citations'] = [];
// Sử dụng các nút chú thích để trích xuất liên kết, biểu tượng, tiêu đề và mô tả trích dẫn

let gptLinksAttached: ChatgptResponse['links_attached'] = [];
// Sử dụng bộ chọn liên kết Markdown để trích xuất liên kết và văn bản của chúng

const body = await page.evaluate(() => document.body.innerHTML);

const cleanBody = body
  .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
  .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
  .replace(/\s+/g, ' ')
  .trim();

const { session_name, task_id, ... } = input;

browser = await this.connectToBrowser({
  session_name,              // Mỗi nhiệm vụ có thể chỉ định một tên phiên riêng biệt
  session_ttl: 600,          // Thời gian sống của phiên
  session_recording,
  proxy_url,
  // ...
});

async solver(input: QueryChatgptRequest, ...): Promise<BaseOutput> {
  let browser: Browser;
  
  try {
    // Tạo một kết nối trình duyệt mới cho mỗi lần gọi
    browser = await this.connectToBrowser(...);
    const page = await browser.newPage();
    // Thực hiện các nhiệm vụ
  } finally {
    // Đóng trình duyệt sau khi nhiệm vụ hoàn tất
    await page.close();
    await browser.close();
  }
}

const { proxy_url } = input;

browser = await this.connectToBrowser({
  proxy_url,  // Mỗi nhiệm vụ có thể sử dụng một proxy khác nhau
  // ...
});

const proxy_country = /-country_([A-Z]{2,3})/.exec(proxy_url)?.[1] || 'ANY';

fingerprint: {
  platform: 'macOS',
  localization: {
    timezone: 'America/New_York',
  },
  args: {
    '--window-size': '1920,1080',
  },
}

const proxy_country = /-country_([A-Z]{2,3})/.exec(proxy_url)?.[1] || 'ANY';

fingerprint: {
  platform: 'macOS',
  localization: {
    timezone: 'America/New_York',
  },
  args: {
    '--window-size': '1920,1080',
  },
}

resolve({
  prompt,
  success: true,
  answer: answerResponse,           // văn bản / html / thô
  country_code: proxy_country,      // thông tin địa lý
  citations: gptCitations,
  links_attached: gptLinksAttached,
  image_cards: gptImageCards,
  products: gptRecommendProducts,
  url: _url,
});

this.pushToMessage(payload, webhook);

return createResponse(JSON.stringify(payload), payload.url);

import puppeteer, { Browser, Page, Target } from 'puppeteer-core';
import fetch from 'node-fetch';
import { PuppeteerLaunchOptions, Scrapeless } from '@scrapeless-ai/sdk';
import { Logger } from '@nestjs/common';

export interface BaseInput {
  task_id: string;
  proxy_url: string;
  timeout: number;
}

export interface BaseOutput {
  url: string;
  data: number[];
  collection?: string;
  dataType?: string;
}

export interface QueryChatgptRequest extends BaseInput {
  prompt: string;
  webhook?: string;
  session_name?: string;
  web_search?: boolean;
  session_recording?: boolean;
  answer_type?: 'text' | 'html' | 'raw';
}

export interface ChatgptResponse {
  prompt: string;
  task_id?: string;
  duration?: number;
  answer?: string;
  url: string;
  success: boolean;
  country_code: string;
  error_reason?: string;
  links_attached?: Partial<{ position: number; text: string; url: string }>[];
  citations?: Partial<{ url: string; icon: string; title: string; description: string }>[];
  products?: Partial<{ url: string; title: string; image_urls: (string | null)[] }>[];
  image_cards?: Partial<{ position: number; url: string }>[];
}

interface StartChatParams extends QueryChatgptRequest {
  page: Page;
  browser: Browser;
}

export class ChatgptService {
  logger = new Logger(this.constructor.name);
  scrapeless = new Scrapeless();

  private timeoutMultiplier = 2;
  private defaultTimeout = 3 * 60 * 1000;
  private internalErrorSymbol = '[InternalError]:';

  async solver(input: QueryChatgptRequest, checkTimeout: () => boolean): Promise<BaseOutput> {
    const { session_name, task_id, webhook, session_recording, proxy_url } = input;

    let browser: Browser;

    const startTime = performance.now();
    const successful = false;

    const getTotalDuration = () => {
      const endTime = performance.now();
      const totalDuration = ((endTime - startTime) / 1000).toFixed(2);
      return totalDuration;
    };

    const handleChatResponse = (data: Partial<ChatgptResponse>) => {
      const payload = { ...data, task_id, duration: getTotalDuration() };
      return payload;
    };

    const createResponse = (data: string, url = 'https://chatgpt.com'): BaseOutput => {
      return {
        url: url,
        data: Array.from(Buffer.from(data)),
        dataType: 'json',
      };
    };

    try {
      browser = await this.connectToBrowser(
        {
          session_name,
          session_ttl: 600,
          session_recording,
          proxy_url,
          fingerprint: {
            platform: 'macOS',
            localization: {
              timezone: 'America/New_York',
            },
            args: {
              '--window-size': '1920,1080',
            },
          },
        },
        checkTimeout,
      );

      const page = await browser.newPage();

      await this.fakePageDate(page);

      const chatParams: StartChatParams = { ...input, page, browser };
      const results = await this.startChat(chatParams);
      const payload = handleChatResponse(results);
      this.pushToMessage(payload, webhook);
      return createResponse(JSON.stringify(payload), payload.url);
    } catch (error) {
      if (error.success) {
        const payload = handleChatResponse(error);
        this.pushToMessage(payload, webhook);
        return createResponse(JSON.stringify(payload), error.url);
      }
      if (error.error_reason) {
        const errorMessage = error.error_reason;
        const payload = handleChatResponse(error);
        this.pushToMessage(payload, webhook);
        this.logger.warn(`Xử lý không thành công: ${errorMessage}`);
        throw { message: !errorMessage.includes(this.internalErrorSymbol) ? errorMessage : '' };
      }
      const errorMessage = error.message || 'Lỗi không xác định';
      const payload = handleChatResponse({
        success: false,
        error_reason: errorMessage,
      });
      this.pushToMessage(payload, webhook);
      this.logger.warn(`Xử lý không thành công: ${errorMessage}`);
      throw error;
    } finally {
      const totalDuration = getTotalDuration();
      this.logger.log(
        `Xử lý ${successful ? 'thành công' : 'đã hoàn thành'} | Thời gian tổng cộng: ${totalDuration} giây`,
      );
    }
  }

async format(data: Uint8Array): Promise<QueryChatgptRequest> {
    if (!data) {
      throw new Error('Không có dữ liệu đầu vào hợp lệ');
    }
    const input = JSON.parse(data.toString()) as QueryChatgptRequest;

    if (!input.prompt) {
      this.logger.error(`prompt là bắt buộc`);
      throw new Error('prompt là bắt buộc');
    }

    return {
      ...input,
      timeout: input.timeout || this.defaultTimeout,
      web_search: input.web_search ?? true,
      session_name: input.session_name || 'Trả lời của Chatgpt',
      session_recording: input.session_recording || false,
      answer_type: input.answer_type || 'văn bản',
    };
  }

  private startChat(params: StartChatParams): Promise<ChatgptResponse> {
    return new Promise(async (resolve, reject: (reason: ChatgptResponse) => void) => {
      const { prompt, answer_type, web_search, timeout, page, browser, proxy_url } = params;
      let action: string;
      let isAborted = false;
      let rawResponse: string;

      this.logger.debug((action = 'Đang kết nối với Trình duyệt'));

      const proxy_country = /-country_([A-Z]{2,3})/.exec(proxy_url)?.[1] || 'BẤT KỲ';
      const query = new URLSearchParams({ q: prompt });
      if (web_search) {
        query.set('hints', 'tìm kiếm');
      }
      const baseUrl = 'https://chatgpt.com';
      const _url = `${baseUrl}/?${query.toString()}`;

      function waitForChatGPTResponse(page: Page): Promise<string> {
        return new Promise((resolve, reject) => {
          let retryCount = 0;
          const CHECK_INTERVAL = 500; // Kiểm tra mỗi 500ms

          const checkResponse = async () => {
            try {
              if (isAborted) {
                resolve('hết thời gian chờ');
                return;
              }
              const currentContent = await page.evaluate(() => {
                const assistantMessage = '[data-message-author-role="assistant"]';
                const $assistantMessages = document.querySelectorAll(assistantMessage);
                const lastMessage = $assistantMessages[$assistantMessages.length - 1];
                if (!lastMessage) return null;

                // Khi có nhiều hơn một nút sao chép xuất hiện, điều đó có nghĩa là câu trả lời của gpt đã hoàn thành
                const $answerCopyButtons = document.querySelectorAll('button[data-testid="copy-turn-action-button"]');
                if ($answerCopyButtons.length > 1) {
                  return lastMessage.textContent || 'Không có nội dung';
                } else {
                  return null;
                }
              });

              // Nếu nội dung chưa thay đổi và không rỗng
              if (currentContent) {
                retryCount++;
                // Nếu nội dung ổn định và không rỗng, phản hồi được coi là hoàn thành
                if (retryCount >= 3) {
                  // Nội dung ổn định trong 1.5 giây
                  resolve(currentContent);
                  return;
                }
              }

              // Tiếp tục kiểm tra
              setTimeout(checkResponse, CHECK_INTERVAL);
            } catch (error) {
              reject(error);
            }
          };

          // Bắt đầu kiểm tra
          checkResponse();
        });
      }

      async function receiveChatGPTStream() {
        const client = await page.createCDPSession();
        await client.send('Fetch.enable', {
          patterns: [
            {
              urlPattern: '*conversation',
              requestStage: 'Phản hồi',
            },
          ],
        });

        client.on('Fetch.requestPaused', async (event) => {
          const { requestId, request, responseHeaders } = event;
          const isSSE = responseHeaders?.some(
            (h) => h.name?.toLowerCase() === 'content-type' && h.value?.includes('text/event-stream'),
          );
          if (request.url.includes('/conversation') && isSSE) {
            try {
              const { body, base64Encoded } = await client.send('Fetch.getResponseBody', { requestId });
              rawResponse = base64Encoded ? Buffer.from(body, 'base64').toString('utf-8') : body;
            } catch (err) {
              console.warn('Không thể lấy phản hồi của luồng', err.message);
            }
          }
          await client.send('Fetch.continueRequest', { requestId });
        });
      }

      function throwError(errorReason: string) {
        const error: ChatgptResponse = {
          prompt,
          success: false,
          country_code: proxy_country,
          error_reason: errorReason,
          url: _url,
        };
        reject(error);
      }

      const timeoutId = setTimeout(() => {
        isAborted = true;
        throwError(`Thời gian chờ Chat hết sau ${timeout}ms`);
      }, timeout);

      try {
        this.logger.debug((action = 'Đăng ký CDP để ghi lại dữ liệu luồng GPT (raw_response)'));
        await receiveChatGPTStream();
        this.logger.debug((action = 'Đang điều hướng đến chatgpt.com'));

    // Thêm listener thay đổi URL
    page.on('framenavigated', async (frame) => {
      if (frame !== page.mainFrame()) return;
      const url = frame.url();
      if (!url.startsWith('https://auth.openai.com')) return;
      isAborted = true;
      throwError(`Chuyển hướng đến trang đăng nhập OpenAI khi <<${_url}>> - ${action}`);
      return;
    });

    if (isAborted) return;
    await this.wait(50, 150);
    this.logger.debug((action = 'Đảm bảo rằng input tồn tại'));
    const inputs = ['#prompt-textarea', '[placeholder="Hỏi bất kỳ điều gì"]'];
    try {
      await Promise.race(
        inputs.map(async (input) => {
          await page.waitForSelector(input, {
            timeout: 20_000 * this.timeoutMultiplier,
            visible: true,
          });
          return input;
        }),
      );
    } catch {
      throwError('Khu vực hiện tại không khả dụng hoặc đã chuyển hướng đến trang đăng nhập');
      return;
    }

    if (isAborted) return;
    await this.wait(150, 250);
    this.logger.debug((action = 'Đợi phản hồi từ GPT'));
    let gptAnswer: string;
    try {
      gptAnswer = await waitForChatGPTResponse(page);
      this.logger.debug((action = 'Đã nhận phản hồi GPT'));
    } catch (error: any) {
      this.logger.error(`Không thể nhận phản hồi: ${error.message}`);
      throwError(`Lấy phản hồi từ chatgpt thất bại`);
      return;
    }

    if (isAborted) return;
    await this.wait(150, 250);
    this.logger.debug((action = 'Lấy thẻ hình ảnh của chatgpt'));
    const imageCardsSelector = 'div.no-scrollbar:has(button img) img';
    const imageCardsLightBoxSelector = 'div[data-testid="modal-image-gen-lightbox"] ol li img';
    const imageCardsLightBoxCloseSelector = 'div[data-testid="modal-image-gen-lightbox"] button';
    let gptImageCards: ChatgptResponse['image_cards'] = [];
    try {
      const firstImageCard = await page.$(imageCardsSelector);
      if (firstImageCard) {
        firstImageCard.click();
        await page.waitForSelector(imageCardsLightBoxSelector);
        gptImageCards = await page.$$eval(imageCardsLightBoxSelector, (elements) => {
          return elements.map((element, index) => {
            const url = element.getAttribute('src') || '';
            return { url, position: index + 1 };
          });
        });
        await page.waitForSelector(imageCardsLightBoxCloseSelector);
        await page.click(imageCardsLightBoxCloseSelector);
      } else {
        this.logger.debug((action = 'Không tìm thấy thẻ hình ảnh'));
      }
    } catch (error: any) {
      this.logger.debug((action = `Lấy thẻ hình ảnh chatgpt: ${error.toString()}`));
    }

    if (isAborted) return;
    await this.wait(300, 450);
    this.logger.debug((action = 'Lấy sản phẩm gợi ý của chatgpt'));
    const closeButtonSelector = `button[data-testid="close-button"]`;
    const recommendProductsSelector = 'div.markdown div.relative > div.flex.flex-row:has(img):not(a) > div img';
    const recommendProductDetailsSelector = `section[screen-anchor="top"] div[slot="content"]`;
    const detailLinkSelector = `${recommendProductDetailsSelector} span a`;
    const gptRecommendProducts: ChatgptResponse['products'] = [];
    try {
      const recommendProducts = await page.$$(recommendProductsSelector);
      if (recommendProducts.length) {
        let lastUrl = '';
        for (const [index] of recommendProducts.entries()) {
          // Chuyển hướng liên kết bên ngoài có thể được kích hoạt
          let newPage: Page = null as unknown as Page;
          const targetCreatedHandler = async (target: Target) => {
            this.logger.debug((action = `Lấy sản phẩm gợi ý của chatgpt: ${target.type()}`));
            try {
              if (target.type() === 'page') {
                const pageTarget = await target.page();
                const opener = await target.opener();
                if (opener && (opener as any)?._targetId === (page.target() as any)?._targetId) {
                  newPage = pageTarget as Page;
                }
              }
            } catch (e) {}
          };
          browser.once('targetcreated', targetCreatedHandler);

          // Nhấp vào mục gợi ý
          await page.evaluate(
            (selector, index) => {
              const currentProduct = document.querySelectorAll(selector)?.[index];

(currentProduct as HTMLElement)?.click();
                },
                recommendProductsSelector,
                index,
              );

              await this.wait(750, 950);
              browser.off('targetcreated', targetCreatedHandler);

              if (newPage) {
                const url = newPage.url();
                const title = await newPage.title();
                gptRecommendProducts.push({ url, title, image_urls: [] });
                await newPage.close();
                continue;
              }

              await page.waitForSelector(detailLinkSelector, { timeout: 20_000 * this.timeoutMultiplier });

              // Chờ để thông tin thay đổi
              let maxRetry = 30;
              while (maxRetry-- > 0) {
                const currentUrl = await page.$eval(detailLinkSelector, (el) => el.getAttribute('href') || '');
                if (currentUrl && currentUrl !== lastUrl) {
                  lastUrl = currentUrl;
                  break;
                }
                await this.wait(200, 300);
              }

              const info = await page.$eval(
                recommendProductDetailsSelector,
                (element, currentUrl) => {
                  const title = element.querySelector('div.text-xl')?.textContent || '';
                  const image_urls = Array.from(element.querySelectorAll('.no-scrollbar img')).map((img) =>
                    img.getAttribute('src'),
                  );
                  return { url: currentUrl, title, image_urls };
                },
                lastUrl,
              );

              gptRecommendProducts.push(info);
            }
            await page.click(closeButtonSelector);
          } else {
            this.logger.debug((action = 'Không tìm thấy sản phẩm gợi ý'));
          }
        } catch (error: any) {
          this.logger.debug((action = `Lấy sản phẩm gợi ý của chatgpt: ${error.toString()}`));
        }

        if (isAborted) return;
        await this.wait(500, 1000);
        this.logger.debug((action = 'Lấy trích dẫn của chatgpt'));
        const citationsEntranceSelector = `button.group\\/footnote`;
        const citationsContentLinkSelector = `section[screen-anchor="top"] div[slot="content"] a`;
        let gptCitations: ChatgptResponse['citations'] = [];
        await page.bringToFront();

        try {
          const citationsButton = await page.waitForSelector(citationsEntranceSelector, {
            timeout: 3_000,
          });
          if (citationsButton) {
            await citationsButton.click();
            const citationsContent = await page.waitForSelector(citationsContentLinkSelector, {
              timeout: 20_000 * this.timeoutMultiplier,
            });
            if (citationsContent) {
              gptCitations = await page.$$eval(citationsContentLinkSelector, (elements) => {
                return elements.map((element) => {
                  const url = element.href || '';
                  const icon = element.querySelector('img')?.getAttribute?.('src');
                  const title = element.querySelector('div:nth-child(2)')?.textContent || '';
                  const description = element.querySelector('div:nth-child(3)')?.textContent || '';
                  return { url, icon, title, description };
                });
              });
              await page.click(closeButtonSelector);
            }
          } else {
            this.logger.debug((action = 'Không tìm thấy trích dẫn'));
          }
        } catch (error: any) {
          this.logger.debug((action = `Lấy trích dẫn của chatgpt: ${error.toString()}`));
        }

        // Trong một số trường hợp, cần thêm một phần tử cố định vào trang
        // để ngăn puppeteer nhấp vào các phần tử ngẫu nhiên
        if (isAborted) return;
        this.logger.debug((action = 'Thêm các phần tử cố định để tránh nhấp chuột không mong muốn'));
        await page.evaluate(() => {
          const element = document.createElement('div');
          element.style.position = 'fixed';
          element.style.top = '0';
          element.style.left = '0';
          element.style.width = '100%';
          element.style.height = '100%';
          element.style.zIndex = '1000';
          document.body.appendChild(element);
        });

        if (isAborted) return;
        await this.wait(150, 250);
        this.logger.debug((action = 'Lấy các liên kết đính kèm của chatgpt'));
        const markdownLinksSelector = 'div.markdown a';
        let gptLinksAttached: ChatgptResponse['links_attached'] = [];
        try {
          gptLinksAttached = await page.$$eval(markdownLinksSelector, (elements) => {
            return elements.map((element, index) => {
              const url = element.href || '';
              const title = element.textContent || '';
              return { url, title, position: index + 1 };
            });
          });
        } catch (error: any) {

    this.logger.debug((action = 'Đang lấy nội dung'));
    const body = await page.evaluate(() => document.body.innerHTML);
    const cleanBody = body
      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '') // Xóa thẻ script
      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '') // Xóa thẻ style
      .replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, '') // Xóa thẻ svg
      .replace(/<img[^>]*\/?>/gi, '') // Xóa thẻ img
      .replace(/style="[^"]*"/gi, '') // Xóa tất cả các thuộc tính style
      .replace(/class="[^"]*"/gi, '') // Xóa tất cả các thuộc tính class
      .replace(/<!--[\s\S]*?-->/g, '') // Xóa các bình luận
      // Chuyển đổi các thay thế liên quan
      .replace(/<span>·<\/span>/g, '') // Xóa thẻ span có ·
      .replace(/<a href="https:\/\/www\.google\.com\/maps\/[^"]*"[^>]*>[\s\S]*?<\/a>/g, '') // Xóa tất cả các liên kết google maps
      .replace(/<a href="tel:+[^"]*"[^>]*>[\s\S]*?<\/a>/g, '') // Xóa tất cả các liên kết điện thoại
      .replace(/\s+/g, ' ') // Chuẩn hóa khoảng trắng
      .trim();

    this.logger.debug((action = 'Kiểm tra phản hồi lỗi'));
    const hasError = [
      'Đã có sự cố xảy ra khi tạo phản hồi.',
      'Hoạt động bất thường đã được phát hiện từ thiết bị của bạn.',
      'Đã xảy ra lỗi. Hoặc động cơ bạn yêu cầu không tồn tại hoặc có vấn đề khác trong việc xử lý yêu cầu của bạn.',
    ].some((message) => cleanBody.includes(message));
    if (hasError) {
      throwError(`ChatGPT hiện không khả dụng`);
      return;
    }

    this.logger.log((action = 'Trò chuyện thành công'));

    const answerMap: Record<QueryChatgptRequest['answer_type'], string> = {
      html: cleanBody,
      raw: rawResponse,
      text: gptAnswer,
    };
    const answerResponse = answerMap[answer_type] ?? answerMap.text;

    resolve({
      prompt,
      success: true,
      answer: answerResponse,
      country_code: proxy_country,
      citations: gptCitations,
      links_attached: gptLinksAttached,
      image_cards: gptImageCards,
      products: gptRecommendProducts,
      url: _url,
    });
  } catch (error: any) {
    if (!isAborted) {
      throwError(this.internalErrorSymbol + (error.message || String(error)));
    }
  } finally {
    clearTimeout(timeoutId);
    try {
      await page.close();
      await browser.close();
    } catch {}
  }
});

  class FakeDate extends OriginalDate {
    constructor(...args: Parameters<typeof Date>) {
      super();
      if (args.length === 0) {
        return new OriginalDate(fixedDate);
      }
      return new OriginalDate(...args);
    }

    static now() {
      return fixedDate.getTime();
    }

    static parse(str: string) {
      return OriginalDate.parse(str);
    }

    static UTC(...args: Parameters<typeof Date.UTC>) {

return OriginalDate.UTC(...args);
        }
      }

      Object.getOwnPropertyNames(OriginalDate).forEach((prop) => {
        FakeDate[prop as keyof typeof FakeDate] = OriginalDate[prop as keyof typeof OriginalDate] as any;
      });
      (window.Date as typeof FakeDate) = FakeDate;
    });
  }

  private async wait(fromMs: number, toMs: number) {
    const ms = fromMs + Math.random() * (toMs - fromMs);
    await new Promise((resolve) => setTimeout(resolve, ms));
  }
}



## Sau khi truy vấn: Biến phản hồi thô thành chiến lược hoạt động GEO có thể hành động trong 30 phút

Hiểu nhanh các kết quả tìm kiếm và xác định các chủ đề nội dung:

1. Sao chép JSON kết quả → Mở [https://csvjson.com/json2csv](https://csvjson.com/json2csv) → lấy CSV → dán vào Excel.
2. Thêm hai cột mới:
   - `brandCount` = `=IF(ISNUMBER(SEARCH("YourBrand",D2)),1,0)`
   - `gap` = `F2-E2` (Cột F là số lần xuất hiện của đối thủ, Cột E là `brandCount`)



![Sau khi truy vấn: Biến phản hồi thô thành chiến lược hoạt động GEO có thể hành động trong 30 phút](https://assets.scrapeless.com/prod/posts/chatgpt-geo/e8bd8631df16a0cd711b83d26b043b9b.png)


👉 **Kết luận:** Hiện tại, không ai đã "đưa ra chủ đề này," vì vậy bạn có thể ngay lập tức viết một bài viết như *“ABCProxy là gì?”* để chiếm lĩnh không gian câu trả lời.  


**Mẹo:** Sau khi thực hiện 100 truy vấn hàng loạt lần tới, sắp xếp theo `gap` giảm dần → 20 kết quả hàng đầu trở thành ý tưởng nội dung ưu tiên.


| Trường        | Ý nghĩa kinh doanh |
|--------------|----------------|
| prompt       | Truy vấn gốc của người dùng |
| answer_text  | Phản hồi đầy đủ từ ChatGPT |
| brandCount   | Số lần thương hiệu của bạn xuất hiện trong câu trả lời |
| rivalCount   | Số lần đối thủ xuất hiện |
| gap          | `rivalCount - brandCount` → `0` = chưa được chiếm lĩnh, nội dung ưu tiên; `>0` = chọn chủ đề ngay lập tức, viết bài so sánh/xếp hạng; `<0` = duy trì cập nhật, tiếp tục tối ưu hóa |

---

## Kết luận

Với Scrapeless Cloud Browser, bạn có thể tự động hóa các truy vấn ChatGPT để đạt được tối ưu hóa GEO xuyên quốc gia, vượt thời gian và dễ dàng có được kết quả tìm kiếm chính xác, địa phương hóa. Dù cho SEO quốc tế, giám sát thương hiệu hay phân tích thông tin thị trường, Scrapeless giúp bạn nhanh chóng xây dựng một hệ thống truy vấn tự động ổn định, hiệu quả, và có thể mở rộng.

Scrapeless không chỉ cung cấp tự động hóa trình duyệt cho dữ liệu GEO mà còn cung cấp các công cụ tiên tiến và chiến lược dữ liệu để kiểm soát hoàn toàn cơ chế trích dẫn AI. Liên hệ với chúng tôi để mở khóa giải pháp dữ liệu GEO hoàn chỉnh!  

Nhìn về phía trước, Scrapeless sẽ tiếp tục tập trung vào công nghệ trình duyệt đám mây, cung cấp cho doanh nghiệp các giải pháp khai thác dữ liệu hiệu suất cao, quy trình tự động và hỗ trợ cơ sở hạ tầng đại lý AI. Phục vụ các ngành như tài chính, bán lẻ, thương mại điện tử, SEO và marketing, Scrapeless cung cấp các giải pháp tùy chỉnh, dựa trên kịch bản để giúp doanh nghiệp đi trước trong kỷ nguyên dữ liệu thông minh.

Scrapeless Browser không chỉ là một công cụ tự động hóa - nó là:  
> **Cơ sở hạ tầng thu thập dữ liệu “hệ sinh thái tìm kiếm AI” có thể mở rộng**  

Cho phép bạn thực sự định lượng khả năng hiển thị thương hiệu ChatGPT, phạm vi từ khóa và xu hướng nội dung.

---

<div style="padding: 20px 0; text-align: center;">
  <a
    style="
      margin: 8px;
      display: inline-block;
      text-decoration: none;
    "
    href="https://www.goproxy.com/register?link=https://app.scrapeless.com/passport/login?utm_source=official&utm_medium=blog&utm_campaign=chatgpt-geo"
  >
    <div
      style="
        font-weight: bold;
        width: 100%;
        max-width: 400px;
        padding: 12px 40px;
        background: #12A594;
        border-radius: 5px;
        border: 2px solid #12A594;
        color: #fff;
        cursor: pointer;
        box-sizing: border-box;
        font-size: 18px;
      "
    >
      👉 Đăng nhập vào Scrapeless Browser &gt;
    </div>
  </a>
</div>