Montei um monitor de preços com IA que me avisa quando o que eu quero baixa de preço

Tem uns meses que eu ando de olho em alguns produtos — um equipamento específico, um livro, um item de hardware — esperando o preço cair antes de comprar. Eu já tentei usar aqueles sites de "alerta de preço" genéricos, mas a maioria é lenta, cheia de anúncio, ou simplesmente não cobre a loja que eu quero acompanhar. Resolvi fazer o meu próprio, rodando num script simples, com um toque de IA pra resolver o problema mais chato desse tipo de automação: páginas que mudam de layout sem avisar.

Esse não é um projeto corporativo nem envolve nada do meu trabalho — é só um script pessoal que qualquer um pode replicar em casa, com qualquer loja pública que você queira acompanhar.

O problema de monitorar preço "na mão"

A ideia óbvia é: escrever um script que abre a página do produto, acha o preço no HTML e compara com o valor salvo anteriormente. Simples — até a loja trocar o CSS da página, ou colocar o preço dentro de um componente JavaScript que só renderiza depois de carregar, ou separar "preço de/por" em dois elementos diferentes. Todo scraper baseado em seletor fixo (span.price, div#final-price etc.) quebra silenciosamente quando isso acontece, e você só percebe quando olha o histórico e vê um buraco de duas semanas sem dados.

Antes de qualquer coisa, porém, vale lembrar que coletar preço de página pública tem limites éticos e técnicos que valem a pena respeitar mesmo num projeto pessoal pequeno: checar o robots.txt do site, não martelar o servidor com requisições em sequência, e preferir uma API oficial quando ela existir.[2] Na prática, isso significa rodar a checagem uma vez por dia (não a cada minuto) e usar um único user-agent identificável.

Passo 1 — Renderizar a página de verdade

Muita loja só preenche o preço via JavaScript depois do carregamento inicial, então um simples requests.get() traz uma página "vazia" sem o número que eu quero. A solução é usar um navegador headless controlado pelo Playwright, que executa o JavaScript da página antes de eu ler o conteúdo:

from playwright.sync_api import sync_playwright def carregar_html(url: str) -> str: with sync_playwright() as pw: browser = pw.chromium.launch(headless=True) context = browser.new_context( user_agent="MonitorDePrecos-Pessoal/1.0 (+contato@exemplo.com)" ) page = context.new_page() page.goto(url, wait_until="networkidle", timeout=20_000) html = page.content() browser.close() return html 

Isso resolve o problema do JavaScript, mas ainda não resolve o problema de "onde está o preço dentro desse HTML gigante" — e é aqui que entra a parte interessante.

Passo 2 — Deixar a IA achar o preço, não um seletor fixo

Em vez de caçar o seletor CSS exato de cada loja (e ter que corrigir o script toda vez que o site muda o layout), eu mando o HTML relevante pra um modelo de linguagem com uma instrução direta e peço só o número de volta, em formato estruturado:

import json def extrair_preco_com_ia(html_resumido: str, nome_produto: str) -> float | None: prompt = f""" Você vai receber um trecho de HTML de uma página de produto. Produto esperado: "{nome_produto}". Extraia APENAS o preço atual de venda (não o preço "de", não frete). Responda em JSON: {{"preco": <número ou null>}} HTML: {html_resumido[:8000]} """ resposta = chamar_llm(prompt) # qualquer cliente de API de LLM dado = json.loads(resposta) return dado.get("preco") 

Na prática eu limpo o HTML antes (removo <script>, <style>, menus e rodapé) pra caber num prompt pequeno e barato — um produto por chamada custa centavos. A vantagem real: se a loja trocar o layout, o script continua funcionando, porque a IA está lendo o texto visível, não uma estrutura de tags fixa. Essa abordagem de localizar o elemento de preço em meio a ruído de página é exatamente o tipo de problema que scrapers tradicionais resolvem com seletores CSS cuidadosamente ajustados;[3] a diferença é que aqui deixo o modelo fazer esse ajuste fino automaticamente, sem eu precisar reabrir o DevTools cada vez que algo muda.

Passo 3 — Guardar o histórico e comparar

Um SQLite simples guarda produto, data e preço. Nada sofisticado:

import sqlite3 from datetime import datetime con = sqlite3.connect("precos.db") con.execute(""" CREATE TABLE IF NOT EXISTS precos ( produto TEXT, url TEXT, preco REAL, data TEXT ) """) def salvar_preco(produto, url, preco): con.execute( "INSERT INTO precos VALUES (?, ?, ?, ?)", (produto, url, preco, datetime.utcnow().isoformat()) ) con.commit() def ultimo_preco(produto): cur = con.execute( "SELECT preco FROM precos WHERE produto=? ORDER BY data DESC LIMIT 1", (produto,) ) row = cur.fetchone() return row[0] if row else None 

A cada execução eu comparo o preço novo com o último salvo. Se caiu (ou ficou abaixo de um limite que eu defini pra aquele produto), disparo o alerta.

Passo 4 — Avisar no Telegram

Um bot do Telegram resolve a notificação sem precisar de nenhum serviço pago. Basta criar o bot com o @BotFather, pegar o token e chamar o endpoint sendMessage:

import requests TOKEN = "SEU_TOKEN_AQUI" def notificar(texto: str, chat_id: str): url = f"https://api.telegram.org/bot{TOKEN}/sendMessage" payload = {"chat_id": chat_id, "text": texto, "parse_mode": "HTML"} resposta = requests.post(url, json=payload, timeout=10).json() if not resposta.get("ok"): raise RuntimeError(resposta.get("description")) 

A chamada exige só chat_id e text — nada de biblioteca extra, é uma requisição HTTP comum.[1] Cada queda de preço detectada gera uma mensagem tipo "📉 Produto X caiu de R$ 420 para R$ 349 — 17% de desconto".

Passo 5 — Agendar e esquecer

Com tudo isso num único script, resta agendar a execução. No Linux/WSL, um cron simples basta:

# todo dia às 9h da manhã 0 9 * * * /usr/bin/python3 /home/usuario/monitor_precos/rodar.py >> /home/usuario/monitor_precos/log.txt 2>&1 

Uma vez por dia é suficiente pra esse tipo de monitoramento pessoal — não há motivo pra rodar de hora em hora, e rodar menos também reduz qualquer impacto no site monitorado.[2]

O que eu aprendi

O ganho real não foi "economizar dinheiro" (embora tenha economizado em uma compra) — foi perceber que o padrão "IA extrai o dado de um conteúdo não estruturado, código tradicional guarda/compara/decide" é muito mais robusto que tentar automatizar tudo com regras fixas. Pra qualquer automação pessoal que lide com páginas web que mudam (preço, disponibilidade de produto, status de entrega), vale a pena pensar nessa divisão: deixe a IA interpretar o texto solto, e deixe código determinístico cuidar da lógica de decisão e do histórico.

📚 Recursos recomendados

  • Cointeligência: A vida e o trabalho com IA — ótimo pra quem quer ir além do "copiar e colar prompt" e pensar como integrar IA de forma estruturada no dia a dia, exatamente o espírito desse tipo de projeto pessoal.[4]

Sources

[1] https://telegram-bot-api.info/guides/telegram-bot-send-message.html — Telegram Bot API - sendMessage guide
[2] https://pricemark.io/pt/blog/web-scraping-ethics-legality — Web scraping de preços: ética e legalidade
[3] https://www.joinmassive.com/blog/price-scraping-python — How to Scrape Prices with Python (2026)
[4] https://www.amazon.com.br/Cointeligência-vida-trabalho-com-IA/dp/8551013157 — Cointeligência: A vida e o trabalho com IA