DEV Community: Nuvem Dev

Python: checar preço de produto passando por proxy residencial (e calcular o custo por página)

Nuvem Dev — Sun, 01 Nov 2026 12:10:53 +0000

Quando o scraping começa a tomar bloqueio, o culpado costuma ser o IP do seu servidor. Aqui vai um script curto que passa a requisição por um proxy (se você tiver um) e já estima quanto aquela página custou em tráfego. Eu rodei esse script de verdade contra um servidor local, sem proxy, só pra validar o código. Não testei com um proxy pago nesta edição.

1. Instala

pip install requests

2. O script

import os, sys, requests

# PROXY_URL no formato http://usuario:senha@host:porta (vem do painel do provedor)
proxy = os.getenv("PROXY_URL")
proxies = {"http": proxy, "https": proxy} if proxy else None

def pega(url):
    r = requests.get(url, proxies=proxies, timeout=15,
                     headers={"User-Agent": "Mozilla/5.0 (compatible; checa-preco/0.1)"})
    r.raise_for_status()
    return r

if __name__ == "__main__":
    url = sys.argv[1]
    r = pega(url)
    kb = len(r.content) / 1024
    print(f"status={r.status_code} tamanho={kb:.1f} KB via_proxy={bool(proxy)}")
    print(f"custo estimado a US$ 5,51/GB: US$ {kb/1024/1024*5.51:.6f}")

3. Rodando

Sem proxy (testei assim, com uma página local):

python checa_preco.py http://localhost:8765/index.html
# status=200 tamanho=0.0 KB via_proxy=False

Com proxy, é só exportar a variável antes:

export PROXY_URL="http://usuario:senha@host:porta"
python checa_preco.py https://exemplo.com.br/produto

Por que o custo por página importa

Proxy residencial é cobrado por giga de tráfego. Na página oficial do IPRoyal (01/11/2026) o preço vai de US$ 7,35/GB no pacote de 1 GB a US$ 5,51/GB no de 10 GB, e o tráfego não expira. Uma página de 200 KB custa na casa de US$ 0,001. O que pesa mesmo é imagem e JavaScript: se der pra pedir só o HTML, o custo cai bastante.

Boas práticas

Leia os termos do site e o robots.txt antes de coletar.
Se existir API oficial, use a API.
Coloque um sleep entre requisições. Rotacionar IP não justifica martelar o servidor dos outros.

Preços e planos do IPRoyal: https://go.nowto.link/iproyal

Se curtiu, a versão newsletter com os números dos pacotes está na Substack: https://nuvemdev.substack.com. E o tutorial anterior (isolamento de perfil com Playwright) está no meu perfil: https://dev.to/nuvemdev

Divulgação: alguns links são de afiliado. Se você comprar, eu posso ganhar uma comissão, sem custo extra pra você.

Isolando sessões de navegador com Playwright em Python (a ideia por trás dos perfis antidetect)

Nuvem Dev — Sat, 31 Oct 2026 12:32:28 +0000

Quem vende online acaba com várias contas abertas: loja, anúncios, marketplace. No mesmo Chrome, cookie e login se misturam. Navegador antidetect resolve isso com perfis isolados. Dá pra entender a ideia em 20 linhas de Python.

O que vamos fazer

Abrir dois "perfis" com Playwright, cada um com cookies, idioma, fuso, user agent e tela próprios, e confirmar que um não enxerga o outro.

Instalação

pip install playwright
playwright install chromium

O código

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    b = p.chromium.launch()
    a = b.new_context(
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/124 Safari/537.36",
        locale="pt-BR", timezone_id="America/Sao_Paulo",
        viewport={"width": 1366, "height": 768})    c = b.new_context(
        user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Chrome/124 Safari/537.36",
        locale="en-US", timezone_id="America/New_York",
        viewport={"width": 1440, "height": 900})
    for nome, ctx in (("A", a), ("B", c)):
        pg = ctx.new_page()
        ctx.add_cookies([{"name": "conta", "value": nome, "url": "http://localhost:8765"}])
        pg.goto("http://localhost:8765")
        print(nome, pg.evaluate("[navigator.language, Intl.DateTimeFormat().resolvedOptions().timeZone, screen.width]"),
              [x["value"] for x in ctx.cookies()])
    b.close()

Antes, suba um servidor local qualquer: python3 -m http.server 8765.

Saída que eu obtive aqui

A ['pt-BR', 'America/Sao_Paulo', 1366] ['A']
B ['en-US', 'America/New_York', 1440] ['B']

Cada contexto tem seu cookie e sua identidade. Nenhum enxerga o do outro.

O que isso NÃO faz

Isso é só isolamento básico. Um navegador antidetect de verdade cuida de dezenas de sinais (canvas, WebGL, fontes), guarda cada perfil, e deixa você abrir pela interface sem código. E nenhuma ferramenta te autoriza a violar regra de plataforma: muita loja proíbe conta duplicada, então leia os termos.

Se não quiser programar

O GoLogin tem plano grátis com 3 perfis e 7 dias de teste completo (conferi na página de preços em 31/10; o Professional, 10 perfis, é US$ 9/mês): https://go.nowto.link/gologin

Mais conteúdo em português na newsletter: https://nuvemdev.substack.com

Alguns links são de afiliado: se você comprar, eu posso ganhar uma comissão, sem custo extra pra você.

Script em Python pra registrar suas músicas de IA e saber quais você pode monetizar

Nuvem Dev — Fri, 30 Oct 2026 12:37:17 +0000

Usar música gerada por IA em vídeo é ótimo até você esquecer em qual plano gerou cada faixa. Em ferramentas como o Suno, a página de preços mostra que o plano Free não tem direitos comerciais, e o Pro (US$ 8/mês) e o Premier (US$ 24/mês) têm. Então vale ter um registro simples de cada música. Vamos fazer isso com um script Python sem dependências.

O script

Salve como musicas.py:

import json, sys, datetime, pathlib
ARQ = pathlib.Path("musicas.json")

def carregar():
    return json.loads(ARQ.read_text()) if ARQ.exists() else []

def registrar(titulo, prompt, plano):
    dados = carregar()
    dados.append({
        "titulo": titulo,
        "prompt": prompt,
        "plano": plano,
        "data": datetime.date.today().isoformat(),
        "comercial": plano.lower() in ("pro", "premier"),
    })
    ARQ.write_text(json.dumps(dados, ensure_ascii=False, indent=2))
def relatorio():
    for m in carregar():
        ok = "OK" if m["comercial"] else "NAO USAR EM VIDEO MONETIZADO"
        print(f'{m["data"]} | {m["titulo"]} | plano {m["plano"]} | {ok}')

if __name__ == "__main__":
    if sys.argv[1] == "add":
        registrar(sys.argv[2], sys.argv[3], sys.argv[4])
    else:
        relatorio()

Usando

python3 musicas.py add "Lofi chuva" "lofi calmo com chuva" free
python3 musicas.py add "Trilha intro" "synth leve otimista" Pro
python3 musicas.py rel

Saída que eu rodei aqui:

2026-10-30 | Lofi chuva | plano free | NAO USAR EM VIDEO MONETIZADO
2026-10-30 | Trilha intro | plano Pro | OK

Por que isso ajuda

Se um cliente ou a plataforma perguntar de onde veio a trilha, você tem prompt, data e plano na mão. É só um JSON, mas evita dor de cabeça. Importante: os termos de uso do serviço podem ter outras limitações, então leia antes de publicar.

Quer a versão em vídeo e os planos explicados? Está na newsletter: https://nuvemdev.substack.com/p/musica-com-ia-pro-seu-video-o-plano

Se quiser testar o Suno: https://go.nowto.link/suno

Outro post prático meu: https://dev.to/nuvemdev/script-em-python-pra-validar-margem-antes-de-abrir-sua-loja-online-4cc

Aviso: o link do Suno é de afiliado; a Nuvem Dev pode receber comissão sem custo extra pra você.

Script em Python pra validar margem antes de abrir sua loja online

Nuvem Dev — Thu, 29 Oct 2026 12:06:33 +0000

Antes de pagar qualquer plataforma de loja (Shopify, Nuvemshop, tanto faz), eu faria uma conta: sobra quanto por venda? Segue um script curto que eu rodei aqui.

O script

def margem(preco, custo, frete, taxa_pct=0.0499, taxa_fixa=0.60, imposto_pct=0.06):
    taxas = preco*taxa_pct + taxa_fixa
    imposto = preco*imposto_pct
    lucro = preco - custo - frete - taxas - imposto
    return round(lucro,2), round(lucro/preco*100,1)

if __name__ == "__main__":
    for preco in (79.9, 99.9, 129.9):
        print(preco, margem(preco, custo=35, frete=18))

Saída real

79.9 (17.52, 21.9)
99.9 (35.32, 35.4)
129.9 (62.02, 47.7)

Com custo de R$ 35 e frete de R$ 18, vender a R$ 79,90 deixa só 21,9% de margem. A R$ 99,90 já vai pra 35%. As taxas (4,99% + R$ 0,60) e o imposto (6%) são valores de exemplo: troque pelos do seu gateway e do seu regime.

Próximo passo

Se a margem fechou, aí sim vale testar uma plataforma. A Shopify tem teste de 3 dias grátis e depois US$ 1/mês por 3 meses (confira na página oficial, promoção muda), e o Shopify Magic, que escreve descrição de produto, é gratuito segundo a central de ajuda deles. Link do teste: https://go.nowto.link/shopify
Contei a versão em newsletter, com vídeo curto, aqui: https://nuvemdev.substack.com. E sobre IA e privacidade, escrevi sobre VPN: https://nuvemdev.substack.com/p/vpn-protege-o-que-voce-digita-na

Aviso: este post contém link de afiliado. Se você assinar pelo link, a Nuvem Dev pode receber uma comissão, sem custo extra pra você.

VPN e IA: o que muda no tráfego, testado com curl (e o que não muda)

Nuvem Dev — Wed, 28 Oct 2026 12:08:32 +0000

Muita gente acha que VPN deixa o uso de IA "privado". Dá pra testar isso em 2 minutos no terminal. Os comandos abaixo eu rodei de verdade; o IP que apareceu foi o de saída da máquina onde rodei.

1. Qual IP o servidor enxerga?

curl -s https://api.ipify.org

Saída no meu teste: 52.26.208.45. Com uma VPN conectada, esse número passa a ser o IP do servidor da VPN, não o seu.

2. O que chega no servidor quando você chama uma API de IA?

Vou usar o httpbin.org como "servidor de mentira" que devolve tudo que recebe:

curl -s -X POST https://httpbin.org/post \
  -H 'Content-Type: application/json' \
  -d '{"model":"exemplo","messages":[{"role":"user","content":"meu prompt secreto"}]}'

Trecho da resposta real:

{
  "data": "{\"model\":\"exemplo\",\"messages\":[{\"role\":\"user\",\"content\":\"meu prompt secreto\"}]}",
  "origin": "52.26.208.45",
  "json": { "messages": [ { "content": "meu prompt secreto", "role": "user" } ] }
}

Duas coisas aparecem: origin (o IP, que a VPN troca) e data (o seu prompt, que a VPN não troca). O texto vai criptografado por HTTPS até o destino, mas o destino lê tudo.

3. Conclusão prática

VPN protege o caminho: Wi-Fi público, provedor de internet, IP de casa.
VPN não protege o conteúdo diante de quem recebe: a empresa da IA vê o prompt e a conta logada.
Se o requisito é "o texto não sai da minha infraestrutura", rode o modelo localmente ou numa VPS sua. Exemplo com Ollama:

curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.2

Eu detalhei VPS vs GPU por hora aqui: https://dev.to/nuvemdev/rodando-llm-em-gpu-alugada-por-hora-checklist-e-comandos-runpod-38if

Quando a VPN ainda vale a pena

Rede pública, esconder navegação do provedor, separar o IP de casa. Conferi em 28/10/2026 a página da NordVPN em português: plano Básico de 2 anos a US$ 3,49/mês e Completo a US$ 3,99/mês (renovação maior: US$ 139,08 e US$ 219,48 por ano), garantia de 30 dias e 10 dispositivos. Link: https://go.nowto.link/nord

Quer receber os próximos testes por e-mail? Assine a newsletter: https://nuvemdev.substack.com

Divulgação: o link da NordVPN é de afiliado. Se você assinar por ele, posso ganhar uma comissão, sem custo extra pra você.

Rodando LLM em GPU alugada por hora: checklist e comandos (RunPod)

Nuvem Dev — Tue, 27 Oct 2026 12:13:09 +0000

Você não precisa de uma GPU em casa pra testar um modelo grande. Dá pra alugar por hora, rodar o que precisa e desligar. Aqui vai um checklist direto, sem enrolação. (Os preços vêm da página oficial da RunPod, conferidos em 27/10/2026, e mudam.)

1. Escolha a GPU pelo tamanho do modelo

A regra prática é olhar a VRAM. Na tabela de pods da RunPod:

GPU	VRAM	Preço/hora
RTX 3090	24 GB	US$ 0,50
RTX 4090	24 GB	US$ 0,89
A100	80 GB	US$ 1,79
H100 PCIe	80 GB	US$ 2,89

Modelos de 7B a 13B quantizados cabem em 24 GB. Modelos de 70B quantizados precisam de mais, tipo 80 GB.

2. Confira a GPU assim que o pod subir

nvidia-smi

Se aparecer o nome da placa e a VRAM livre, tá tudo certo.

3. Rode um modelo com Ollama

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
ollama run llama3.1:8b "Explique o que é VRAM em duas frases"

Em outro terminal, veja a placa trabalhando:

watch -n 1 nvidia-smi

4. Ou suba uma API compatível com OpenAI (vLLM)

pip install vllm
vllm serve Qwen/Qwen2.5-7B-Instruct --port 8000
curl http://localhost:8000/v1/models

5. Desligue tudo no final

Pod ligado é dinheiro saindo. Parou de usar, pare o pod. Lembre também que disco (volume) tem cobrança própria, mesmo com o pod parado: na tabela, volume ocioso custa US$ 0,20/GB/mês.

GPU por hora ou VPS?

IA no ar o dia inteiro (chatbot, automação): uma VPS sai mais previsível, mas sem GPU roda só modelo pequeno. Teste, treino e modelo grande por poucas horas: GPU por hora. Montei o passo a passo da versão VPS neste outro post: https://dev.to/nuvemdev

Links (afiliado):

RunPod: https://go.nowto.link/runpod
Hostinger VPS: https://go.nowto.link/hostinger

Recebo a newsletter com os comparativos e vídeos curtos aqui: https://nuvemdev.substack.com

Aviso: alguns links são de afiliado. Se você comprar por eles, posso receber uma comissão, sem custo adicional pra você.

Ollama + Open WebUI numa VPS: seu ChatGPT privado em 10 minutos

Nuvem Dev — Mon, 26 Oct 2026 23:38:32 +0000

Vamos direto ao que interessa. Você tem uma VPS Ubuntu com pelo menos 8 GB de RAM e quer rodar um modelo de IA aberto com interface web. São quatro passos.

1. Instalar o Ollama

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

2. Baixar um modelo pequeno

Sem GPU, comece com modelos de 3B a 8B parâmetros. Em 8 GB de RAM, o 3B é o mais confortável:

ollama pull llama3.2:3b
ollama run llama3.2:3b "Explique o que é uma VPS em duas frases"

3. Instalar o Docker e subir o Open WebUI

curl -fsSL https://get.docker.com | sh
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/open-webui \
  --name open-webui --restart always \
  ghcr.io/open-webui/open-webui:main

Abra http://IP_DA_VPS:3000, crie o usuário admin (o primeiro cadastro vira admin) e ele detecta o Ollama.

Se não detectar, ajuste o Ollama pra escutar fora do localhost: sudo systemctl edit ollama, adicione Environment="OLLAMA_HOST=0.0.0.0" e rode sudo systemctl restart ollama.

4. Fechar o acesso

Não deixe a porta 3000 aberta pro mundo:

sudo ufw allow OpenSSH
sudo ufw allow from SEU_IP to any port 3000
sudo ufw enable

Limites

CPU puro é lento: espere respostas bem mais devagar que no ChatGPT. Pra modelos grandes, aluguel de GPU por hora faz mais sentido.

Plano de referência: Hostinger (KVM 2: 2 vCPU, 8 GB RAM, R$ 42,99/mês na promo atual, preço verificado em 26/10): https://go.nowto.link/hostinger

Vídeo e newsletter: https://nuvemdev.substack.com . Também escrevi sobre voz de IA em português: https://dev.to/nuvemdev/narracao-em-portugues-com-ia-de-graca-no-linux-piper-tts-ffmpeg-575h

Alguns links são de afiliado: se você comprar, eu ganho uma comissão e você não paga nada a mais.

Narração em português com IA, de graça, no Linux (Piper TTS + ffmpeg)

Nuvem Dev — Fri, 23 Oct 2026 23:09:43 +0000

Esse short de 32 segundos foi narrado inteiro com o que tá nesse tutorial. Clica pra ver (ele roda na newsletter).

Eu precisava de narração em português pros meus vídeos curtos e não queria depender de API paga logo de cara. A saída foi o Piper: um TTS open source (GPL-3.0) que roda offline, na CPU, e tem voz pt-BR.

Aqui vai o caminho que eu usei, do zero até um mp4 vertical. Rodei tudo isso num Debian, com Python 3.12, em outubro de 2026, com o piper-tts 1.8.0.

1. Instalar

Cria uma venv pra não bagunçar o Python do sistema:

mkdir narracao && cd narracao
python3 -m venv .venv
source .venv/bin/activate
pip install piper-tts

Não precisa de GPU. O pacote já vem com o que ele usa pra fonemas (espeak-ng embutido).

2. Baixar a voz pt-BR

A voz brasileira que eu uso é a faber, qualidade medium (dataset CC0, segundo o model card):

python3 -m piper.download_voices pt_BR-faber-medium

Isso baixa dois arquivos na pasta atual: pt_BR-faber-medium.onnx (uns 63 MB) e o .onnx.json de config. Os dois precisam ficar juntos.

3. Primeiro áudio

echo "Fala, pessoal! Essa narração foi gerada de graça, rodando no meu servidor." > roteiro.txt
python3 -m piper -m pt_BR-faber-medium.onnx -i roteiro.txt -f narracao.wav

Aqui levou menos de 2 segundos pra gerar uns 4 segundos de áudio, na CPU. Confere o arquivo:

ffprobe -v error -show_entries format=duration:stream=sample_rate,channels -of default=nw=1 narracao.wav
# sample_rate=22050
# channels=1
# duration=4.179592

Flags que valem conhecer (python3 -m piper --help mostra todas):

--length-scale 1.1 deixa a fala mais lenta; 0.9 acelera
--sentence-silence 0.3 coloca pausa entre frases
--volume 1.2 aumenta o volume

4. Em lote, com Python

Pra vídeo eu gosto de gerar um arquivo por cena, porque fica fácil sincronizar legenda e imagem depois. Uma linha do roteiro = uma cena:

# narrar.py
import sys, wave
from piper import PiperVoice, SynthesisConfig

voz = PiperVoice.load("pt_BR-faber-medium.onnx")
cfg = SynthesisConfig(length_scale=0.95)  # < 1 = fala mais rápido

with open(sys.argv[1], encoding="utf-8") as f:
    blocos = [l.strip() for l in f if l.strip()]

for i, texto in enumerate(blocos, 1):
    with wave.open(f"parte_{i:02d}.wav", "wb") as wav:
        voz.synthesize_wav(texto, wav, syn_config=cfg)
    print(f"parte_{i:02d}.wav  <- {texto[:40]}")

printf "Primeira frase do roteiro.\nSegunda frase, um pouco mais longa, pra testar o ritmo.\n" > roteiro2.txt
python3 narrar.py roteiro2.txt

Dica de quem apanhou: nome de marca em inglês ele lê do jeito dele. Eu mantenho duas versões do texto, uma pra legenda ("ElevenLabs") e outra pra voz, escrita do jeito que eu quero ouvir ("Íleven Labs").

5. Juntar e normalizar o volume

Plataforma de vídeo curto costuma trabalhar perto de -14 LUFS. O loudnorm do ffmpeg resolve:

for f in parte_*.wav; do echo "file '$f'"; done > lista.txt
ffmpeg -f concat -safe 0 -i lista.txt \
  -af loudnorm=I=-14:TP=-1.5:LRA=11 -ar 44100 narracao_final.wav

Pra conferir quanto deu:

ffmpeg -i narracao_final.wav -af ebur128 -f null - 2>&1 | grep -A1 Integrated

Num clipe curto o loudnorm de uma passada fica um pouco abaixo do alvo (aqui deu -14,9). Pra short isso tá ok; se quiser cravar, faz o loudnorm em duas passadas.

6. Virar vídeo vertical

O mínimo: uma imagem 1080x1920 + a narração.

ffmpeg -loop 1 -i capa.png -i narracao_final.wav \
  -vf "scale=1080:1920,format=yuv420p" -r 30 \
  -c:v libx264 -tune stillimage -c:a aac -b:a 160k \
  -shortest video.mp4

ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate -of compact video.mp4
# stream|codec_name=h264|width=1080|height=1920|r_frame_rate=30/1
# stream|codec_name=aac|r_frame_rate=0/0

No meu pipeline eu vou além disso (uma cena por imagem com zoom lento via zoompan, legenda em .ass queimada com o filtro ass=), mas o esqueleto é esse aí.

Limites, sendo sincero

A voz é boa pra tutorial e pra testar formato. Mas a entonação é mais reta que a dos serviços pagos e às vezes escorrega numa palavra. Se o projeto pede voz bem natural, ou clonar a sua, aí vale olhar ElevenLabs ou Murf. Eu comparei preço por minuto das duas (e da Fish Audio, que hoje não lista português no TTS) nessa edição da newsletter.

Se travar em algum passo, comenta aqui com o erro que eu tento ajudar.

Alguns links da newsletter são de afiliado: se você comprar, eu ganho uma comissão e você não paga nada a mais.