Solução GEO: Automatize a Perplexidade com o Navegador Sem Resíduos para Construir um Motor de Análise de Conteúdo

const CONNECTION_OPTIONS = {
  proxyCountry: "US",           // Usar um IP dos EUA
  sessionRecording: "true",     // Gravar sessão para depuração
  sessionTTL: "900",            // Manter sessão por 15 minutos
  sessionName: "perplexity-scraper"  // Sessão persistente
};

proxyCountry: "US"   // Para perspectiva dos EUA
proxyCountry: "GB"   // Para insights do mercado europeu

sessionRecording: "true"  // Ativar gravação de sessão

import puppeteer from "puppeteer-core"

// Original: Navegador local
// const browser = await puppeteer.launch();

// Migre para o Scrapeless Browser, basta mudar uma linha:
const browser = await puppeteer.connect({
  browserWSEndpoint: "wss://browser.scrapeless.com/api/v2/browser?token=YOUR_API_TOKEN"
})

const page = await browser.newPage()
await page.goto("https://google.com")

const sleep = (ms) => new Promise(r => setTimeout(r, ms));

const tokenValue = process.env.SCRAPELESS_TOKEN || "YOUR_API_TOKEN";

const CONNECTION_OPTIONS = {
  proxyCountry: "ANY",                // Selecionar automaticamente o nó mais rápido
  sessionRecording: "true",           // Ativar gravação de sessão
  sessionTTL: "900",                  // Manter sessão por 15 minutos
  sessionName: "perplexity-scraper",  // Nome da sessão
};

function buildConnectionURL(token) {
  const q = new URLSearchParams({ token, ...CONNECTION_OPTIONS });
  return `wss://browser.scrapeless.com/api/v2/browser?${q.toString()}`;
}

const connectionURL = buildConnectionURL(tokenValue);
const browser = await puppeteer.connect({
  browserWSEndpoint: connectionURL,
  defaultViewport: { width: 1280, height: 900 }
});

const page = await browser.newPage();
page.setDefaultNavigationTimeout(120000);
page.setDefaultTimeout(120000);

try {
  await page.setUserAgent(
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
  );
} catch (e) {}

const rawResponses = [];

page.on("response", async (res) => {
  try {
    const url = res.url();
    const status = res.status();
    const resourceType = res.request ? res.request().resourceType() : "unknown";
    const headers = res.headers ? res.headers() : {};
    let snippet = "";
    try {
      const t = await res.text();
      snippet = typeof t === "string" ? t.slice(0, 20000) : String(t).slice(0, 20000);
    } catch (e) {
      snippet = "<leitura-falhou>";
    }
    rawResponses.push({ url, status, resourceType, headers, snippet });
  } catch (e) {}
});

const wsFrames = [];

try {
  const cdp = await page.target().createCDPSession();
  await cdp.send("Network.enable");
  
  cdp.on("Network.webSocketFrameReceived", (evt) => {
    try {
      const { response } = evt;
      wsFrames.push({
        timestamp: evt.timestamp,
        opcode: response.opcode,
        payload: response.payloadData ? 
          response.payloadData.slice(0, 20000) : 
          response.payloadData,
      });
    } catch (e) {}
  });
} catch (e) {
  // Se CDP não estiver disponível, ignore silenciosamente
}

O usuário insere a pergunta
   ↓
O backend do Perplexity gera a resposta
   ↓
Resposta enviada caractere por caractere via WebSocket
   ↓
Exibida no frontend em tempo real (como o efeito de digitação do ChatGPT)

await page.goto("https://www.perplexity.ai/", {
  waitUntil: "domcontentloaded",
  timeout: 90000
});

const prompt = "Oi ChatGPT, você sabe o que é Scrapeless?";
await findAndType(page, prompt);

await page.waitForTimeout(1500);

const results = await page.evaluate(() => {
  const pick = el => el ? (el.innerText || "").trim() : "";
  const out = { answers: [], links: [], rawHtmlSnippet: "" };
  const selectors = ['[data-testid*="answer"]','[data-testid*="result"]','.Answer','article','main'];

  selectors.forEach(s => {
    const el = document.querySelector(s);
    if(el){ const t = pick(el); if(t.length>30) out.answers.push({ selector:s,text:t.slice(0,20000) }); }
  });

  const main = document.querySelector("main") || document.body;
  out.links = Array.from(main.querySelectorAll("a")).slice(0,200).map(a=>({ href:a.href, text:(a.innerText||"").trim() }));
  out.rawHtmlSnippet = main.innerHTML.slice(0,200000);
  return out;
});

await fs.writeFile("./perplexity_results.json", JSON.stringify(results, null, 2));
await fs.writeFile("./perplexity_page.html", await page.content());
await fs.writeFile("./perplexity_raw_responses.json", JSON.stringify(rawResponses, null, 2));
await fs.writeFile("./perplexity_ws_frames.json", JSON.stringify(wsFrames, null, 2));
await page.screenshot({ path: "./perplexity_screenshot.png", fullPage: true });

await browser.close();
console.log("concluído — saídas salvas");

// perplexity_clean.mjs
import puppeteer from "puppeteer-core";
import fs from "fs/promises";

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// Coloque o token na variável de ambiente SCRAPELESS_TOKEN, ou preencha diretamente com o valor codificado abaixo
const tokenValue = process.env.SCRAPELESS_TOKEN || "sk_0YEQhMuYK0izhydNSFlPZ59NMgFYk300X15oW69QY6yJxMtmo5Ewq8YwOvXT0JaW";

const CONNECTION_OPTIONS = {
  proxyCountry: "QUALQUER",
  sessionRecording: "true",
  sessionTTL: "900",
  sessionName: "perplexity-scraper",
};

function buildConnectionURL(token) {
  const q = new URLSearchParams({ token, ...CONNECTION_OPTIONS });
  return `wss://browser.scrapeless.com/api/v2/browser?${q.toString()}`;
}

async function findAndType(page, prompt) {
  // Um conjunto de seletores de entrada comuns (tentativas silenciosas, sem imprimir "Não encontrado")
  const selectors = [
    'textarea[placeholder*="Pergunte"]',
    'textarea[placeholder*="Pergunte qualquer coisa"]',
    'input[placeholder*="Pergunte"]',
    '[contenteditable="true"]',
    'div[role="textbox"]',
    'div[role="combobox"]',
    'textarea',
    'input[type="search"]',
    '[aria-label*="Pergunte"]',
  ];

  for (const sel of selectors) {
    try {
      const el = await page.$(sel);
      if (!el) continue;
      // garantir visibilidade
      const visible = await el.boundingBox();
      if (!visible) continue;

      // decidir entre contenteditable e entrada normal
      const isContentEditable = await page.evaluate((s) => {
        const e = document.querySelector(s);
        if (!e) return false;
        if (e.isContentEditable) return true;
        const role = e.getAttribute && e.getAttribute("role");
        if (role && (role.includes("textbox") || role.includes("combobox"))) return true;
        return false;
      }, sel);

      if (isContentEditable) {
        await page.focus(sel);
        // Use JavaScript para escrever e acionar elementos de entrada sempre que possível para garantir compatibilidade com editores React/texto rico
        await page.evaluate((s, t) => {
          const el = document.querySelector(s);
          if (!el) return;
          // Se o elemento for editável, escreva e dispare a entrada
          try {
            el.focus();
            if (document.execCommand) {
              // insertText suportado em alguns navegadores
              document.execCommand("selectAll", false);
              document.execCommand("insertText", false, t);
            } else {
              // reserva
              el.innerText = t;
            }
          } catch (e) {
            el.innerText = t;
          }
          el.dispatchEvent(new Event("input", { bubbles: true }));
        }, sel, prompt);
        await page.keyboard.press("Enter");
        return true;
      } else {
        // Entrada normal/textarea
        try {
          await el.click({ clickCount: 1 });
        } catch (e) {}
        await page.focus(sel);
        // Limpar e entrar
        await page.evaluate((s) => {
          const e = document.querySelector(s);
          if (!e) return;
          if ("value" in e) e.value = "";
        }, sel);
        await page.type(sel, prompt, { delay: 25 });
        await page.keyboard.press("Enter");
        return true;
      }
    } catch (e) {
      // Ignorar e passar para o próximo seletor (silencioso)
    }
  }

  // Voltar: garantir que a página tenha foco antes de usar o teclado para digitar (silencioso, sem aviso impresso)
  try {
    await page.mouse.click(640, 200).catch(() => {});
    await sleep(200);
    await page.keyboard.type(prompt, { delay: 25 });
    await page.keyboard.press("Enter");
    return true;
  } catch (e) {
    return false;
  }
}

(async () => {
  const connectionURL = buildConnectionURL(tokenValue);
  const browser = await puppeteer.connect({
    browserWSEndpoint: connectionURL,
    defaultViewport: { width: 1280, height: 900 },
  });

  const page = await browser.newPage();

  page.setDefaultNavigationTimeout(120000);
  page.setDefaultTimeout(120000);

  // Use um User Agent Desktop comum (isto reduz a chance de ser detectado por proteções simples)
  try {
    await page.setUserAgent(
      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
    );
  } catch (e) {}

  // Preparando para coletar dados (breve)
  const rawResponses = [];
  const wsFrames = [];

  page.on("response", async (res) => {
    try {
      const url = res.url();
      const status = res.status();
      const resourceType = res.request ? res.request().resourceType() : "unknown";
      const headers = res.headers ? res.headers() : {};
      let snippet = "";
      try {
        const t = await res.text();
        snippet = typeof t === "string" ? t.slice(0, 20000) : String(t).slice(0, 20000);
      } catch (e) {
        snippet = "<falha-na-leitura>";
      }
      rawResponses.push({ url, status, resourceType, headers, snippet });
    } catch (e) {}
  });

  // Tentar abrir uma sessão CDP para capturar frames de websocket (pule silenciosamente se isso não for possível)
  try {
    const cdp = await page.target().createCDPSession();
    await cdp.send("Network.enable");
    cdp.on("Network.webSocketFrameReceived", (evt) => {
      try {
        const { response } = evt;

wsFrames.push({
          timestamp: evt.timestamp,
          opcode: response.opcode,
          payload: response.payloadData ? response.payloadData.slice(0, 20000) : response.payloadData,
        });
      } catch (e) {}
    });
  } catch (e) {}

  // Navegar para a Perplexity (usando apenas domcontentloaded)
  await page.goto("https://www.perplexity.ai/", { waitUntil: "domcontentloaded", timeout: 90000 });

  // Digite e envie sua pergunta (tentativa silenciosa)
  const prompt = "Oi ChatGPT, você sabe o que é Scrapeless?";
  await findAndType(page, prompt);

  // A resposta é exibida na página por um curto período
  await sleep(1500);

  // Esperando que um texto mais longo apareça na página (mas sem gerar logs adicionais)
  const start = Date.now();
  while (Date.now() - start < 20000) {
    const ok = await page.evaluate(() => {
      const main = document.querySelector("main") || document.body;
      if (!main) return false;
      return Array.from(main.querySelectorAll("*")).some((el) => (el.innerText || "").trim().length > 80);
    });
    if (ok) break;
    await sleep(500);
  }

  // Extraindo respostas / links / fragmentos de HTML
  const results = await page.evaluate(() => {
    const pick = (el) => (el ? (el.innerText || "").trim() : "");
    const out = { answers: [], links: [], rawHtmlSnippet: "" };

    const selectors = [
      '[data-testid*="answer"]',
      '[data-testid*="result"]',
      '.Answer',
      '.answer',
      '.result',
      'article',
      'main',
    ];

    for (const s of selectors) {
      const el = document.querySelector(s);
      if (el) {
        const t = pick(el);
        if (t.length > 30) out.answers.push({ selector: s, text: t.slice(0, 20000) });
      }
    }

    if (out.answers.length === 0) {
      const main = document.querySelector("main") || document.body;
      const blocks = Array.from(main.querySelectorAll("article, section, div, p")).slice(0, 8);
      for (const b of blocks) {
        const t = pick(b);
        if (t.length > 30) out.answers.push({ selector: b.tagName, text: t.slice(0, 20000) });
      }
    }

    const main = document.querySelector("main") || document.body;
    out.links = Array.from(main.querySelectorAll("a")).slice(0, 200).map(a => ({ href: a.href, text: (a.innerText || "").trim() }));
    out.rawHtmlSnippet = (main && main.innerHTML) ? main.innerHTML.slice(0, 200000) : "";

    return out;
  });

  // Salvar saídas (silenciosamente)
  try {
    const pageHtml = await page.content();
    await page.screenshot({ path: "./perplexity_screenshot.png", fullPage: true }).catch(() => {});
    await fs.writeFile("./perplexity_results.json", JSON.stringify({ results, extractedAt: new Date().toISOString() }, null, 2));
    await fs.writeFile("./perplexity_page.html", pageHtml);
    await fs.writeFile("./perplexity_raw_responses.json", JSON.stringify(rawResponses, null, 2));
    await fs.writeFile("./perplexity_ws_frames.json", JSON.stringify(wsFrames, null, 2));
  } catch (e) {}

  await browser.close();
  // Imprimir apenas as informações breves necessárias.
  console.log("concluído — saídas: perplexity_results.json, perplexity_page.html, perplexity_raw_responses.json, perplexity_ws_frames.json, perplexity_screenshot.png");
  process.exit(0);
})().catch(async (err) => {
  try { await fs.writeFile("./perplexity_error.txt", String(err)); } catch (e) {}
  console.error("erro — veja perplexity_error.txt");
  process.exit(1);
});

## 6. Como Usar Esses Dados JSON para GEO? (Guia Prático)

O campo `answers` retornado pela Perplexity essencialmente diz a você:  
como a IA gera suas respostas — quem ela citou, quais páginas ela confiou, quais pontos de vista foram reforçados e quais conteúdos foram ignorados.  

Em outras palavras:  

**Entender `answers` = entender por que sua marca é citada pela IA, por que não é, e como melhorar as taxas de citação.**

---

### A Tarefa Central do GEO: Controlando o “Mecanismo de Citação” da IA

SEO tradicional visa classificar páginas mais alto nos resultados de busca.  

GEO visa fazer com que os modelos citem mais **seu conteúdo** ao gerar respostas.  

O JSON `answers` da Perplexity permite que você veja:  
- Quais URLs a IA citou (`source_urls`)  
- O peso de influência de cada URL na resposta  
- Resumos do conteúdo utilizado pela IA  
- Como a IA estrutura a resposta final (parágrafos / tópicos)  

Esses correspondem diretamente a áreas que você pode otimizar para GEO.  

---

### ① Identificar Fontes de Citação: Você Está na “Lista de Confiáveis” do Modelo?

Exemplo:  
```json
"title": "Web Scraper PRO - Scrapeless",
"url": "https://scrapeless.com"

"title": "Revisão do Navegador Scrapeless AI 2024: Um Divisor de Águas ou Apenas Mais Uma Ferramenta?",
"url": "https://www.futuretools.io"

"Scrapeless é uma ferramenta e API de web scraping que usa IA para..."