Website Screenshot API

npx add-mcp 'https://mcp.apify.com/?actors=catalyst-labs/website-screenshot-pdf-api'

API de Captura de Tela e PDF de Sites (catalyst-labs/website-screenshot-pdf-api) Actor

Capture capturas de tela de página inteira (PNG, JPEG, WebP) e PDFs de qualquer URL. Remove banners de cookies, carrega imagens lazy, corrige cabeçalhos fixos, renderiza emoji e texto CJK. Presets para desktop, tablet e celular. Você paga apenas por capturas bem-sucedidas.

• URL: https://apify.com/catalyst-labs/website-screenshot-pdf-api.md
• Desenvolvido por: Catalyst Labs (comunidade)
• Categorias: Ferramentas para desenvolvedores, IA, Automação
• Estatísticas: 2 usuários no total, 1 usuário mensal, 100,0% de execuções bem-sucedidas, 0 favoritos
• Avaliação dos usuários: Ainda sem avaliações

Preços

a partir de US$ 5,00 / 1.000 capturas de tela realizadas

Este Actor é cobrado por evento. Você não é cobrado pelo uso da plataforma Apify, mas apenas um preço fixo por eventos específicos. Como este Actor oferece suporte a descontos do Apify Store, o preço diminui quanto maior for o seu plano de assinatura.

Saiba mais: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

O que é um Apify Actor?

Um Actor é um programa de nuvem serverless que é executado na plataforma Apify. Ele tem dois modos de execução. No modo Batch, um Actor aceita uma entrada JSON bem definida, executa uma ação que pode levar de alguns segundos a algumas horas, e opcionalmente produz uma saída JSON bem definida, conjuntos de dados com resultados ou arquivos no key-value store. No modo Standby, um Actor fornece um servidor web que pode ser usado como site, API ou servidor MCP.

O vocabulário do Apify e o modelo da plataforma são definidos uma única vez, no guia de início rápido para agentes em https://apify.com/agents.md.

Como integrar um Actor?

Se perguntarem sobre integração, você ajuda os desenvolvedores a integrar Actors em seus projetos. Você se adapta à stack deles e entrega integrações seguras, bem documentadas e prontas para produção.

Não adivinhe um caminho de integração. Todos eles estão no guia de início rápido para agentes em https://apify.com/agents.md: o servidor MCP do Apify, Agent Skills com o Apify CLI, os clientes JavaScript e Python, a REST API e o caminho sem conta para um agente sem humano para fazer login. Ele também traz a regra sobre declarar o custo antes da primeira execução paga.

Para exemplos já conectados ao schema de entrada deste Actor, consulte a seção API abaixo.

Cada biblioteca cliente tem documentação de referência que o guia de início rápido não repete: JavaScript/TypeScript (npm install apify-client) e Python (pip install apify-client).

README

O que é a API de Captura de Tela e PDF de Sites?

A API de Captura de Tela e PDF de Sites transforma qualquer URL pública em uma captura de tela de página inteira (PNG, JPEG ou WebP) ou um PDF, com um link direto para cada arquivo. Forneça uma URL ou alguns milhares. Ela carrega cada página em um navegador Chrome real, fecha banners de cookies, carrega imagens lazy, exibe cabeçalhos fixos uma vez em vez de em cada tela, executa animações acionadas por rolagem até seu estado final, oculta widgets de chat e popups, e então captura a página em desktop, tablet ou celular.

Você paga apenas pelos arquivos que foram realmente capturados. Páginas que falham, expiram, são bloqueadas por proteção contra bots, retornam erro HTTP ou renderizam em branco são reportadas com um motivo e uma dica de correção, e nunca são cobradas.

No Apify você também obtém uma REST API, acesso MCP para agentes de IA, agendamento, webhooks e integrações (Make, Zapier, n8n, Google Drive e mais) sem executar nenhum servidor ou navegador por conta própria.

Como usar a API de Captura de Tela e PDF de Sites

1. Clique em Experimente gratuitamente (ou Iniciar) e abra a aba Input.
2. Adicione suas URLs, uma por linha. https:// é opcional.
3. Escolha os formatos (PNG é o padrão; adicione pdf, jpeg ou webp) e um dispositivo (desktop, desktop-hd, laptop, tablet, mobile).
4. Clique em Iniciar. Cada arquivo aparece na aba Output com uma prévia e um link de download fileUrl. Os arquivos ficam no key-value store da execução, e o registro OUTPUT contém um resumo da execução.

---

Para agentes de IA

O que faz: fornece uma imagem ou PDF de uma página web para que você possa "vê-la": um registro de conjunto de dados por URL e formato, com fileUrl (um link direto para download), width/height, title e status.

Entrada mínima (apenas urls é obrigatório):

{ "urls": ["https://example.com"] }

Primeira chamada econômica (um JPEG acima da dobra, US$ 0,018 no plano Free: US$ 0,01 de início de execução + US$ 0,008 de captura de tela):

{ "urls": ["https://example.com"], "formats": ["jpeg"], "fullPage": false }

• Nome da ferramenta MCP: catalyst-labs--website-screenshot-pdf-api (conecte https://mcp.apify.com/?tools=catalyst-labs/website-screenshot-pdf-api), ou use call-actor com catalyst-labs/website-screenshot-pdf-api.
• Custo: US$ 0,01 por execução, mais US$ 0,008 por captura de tela no plano Free (até US$ 0,005 no Gold e acima) e US$ 0,012 por PDF. URLs com falha, bloqueadas, em branco e ignoradas são gratuitas. Passe maxTotalChargeUsd nas opções de execução para um limite rígido. URLs que não se encaixam no limite são ignoradas e marcadas como SPENDING_LIMIT, e a execução ainda termina como SUCCEEDED.
• Campos de saída: url, status (success / failed / skipped), format, fileUrl, key, bytes, width, height, pageHeight, truncatedAtMaxHeight, pdfPages, title, finalUrl, httpStatus, cookieBannerDismissed, errorType, hint. O registro OUTPUT lista cada URL com seu status e uma hint de correção, para que você possa tentar novamente por conta própria (por exemplo, com um proxy residencial após BLOCKED).
• Velocidade: com os 4 GB padrão, uma página típica leva de 5 a 60 segundos, e páginas muito altas ou com muitas animações levam até cerca de 2 minutos (agora são capturadas por completo). Com 2 GB (meio vCPU), espere aproximadamente o dobro disso. Duas páginas são executadas em paralelo com 2 a 4 GB de memória (4 com 8 GB); novas páginas aguardam enquanto a memória ou a CPU estiverem saturadas. Permissões limitadas, pagamento por evento, sem Standby.
• Limitações conhecidas: páginas somente para login precisam de cookies. Sites com forte proteção contra bots (por exemplo, NYTimes, WSJ, Indeed, G2 ou Zillow) bloqueiam IPs de data center. O proxy residencial do Apify (proxyConfiguration) consegue passar em alguns deles (El País, às vezes NYTimes em nossos testes), mas não de forma confiável nos muros mais fortes; esses falham como BLOCKED e não são cobrados. Capturas de página inteira são cortadas em maxHeight (padrão de 36.000 pixels de dispositivo: 36.000 px CSS no desktop, 12.000 no celular a 3x; máximo de 50.000 px CSS; WebP para em 16.383 px), e o corte é sinalizado na saída.

Quando escolher esta ferramenta

Fatos que você pode verificar na saída da execução:

• Cobrança apenas por arquivos entregues. URLs com falha, bloqueadas (verificação de bot), com erro HTTP, em branco e acima do orçamento são reportadas com errorType e uma hint, e são gratuitas.
• Quatro formatos em uma execução: PNG, JPEG, WebP e PDF (tamanho de papel, margens, paisagem, mídia de impressão/tela, ou uma única página longa).
• Banners de cookies fechados em mais de 30 plataformas de consentimento (OneTrust, Didomi, Sourcepoint, Quantcast, Cookiebot, Usercentrics e outras) além de texto "Aceitar" em mais de 30 idiomas; testado em The Guardian, BBC, Spiegel, Le Monde, Corriere e nu.nl.
• Imagens lazy carregadas, páginas em crescimento roladas até pararem de crescer (com limite), animações acionadas por rolagem concluídas e cabeçalhos fixos exibidos uma vez em capturas de página inteira; emoji e texto em chinês/japonês/coreano/árabe são renderizados com fontes incluídas.
• Testado na nuvem do Apify em 39 URLs × 2 dispositivos mais 10 cenários de opções antes do lançamento (veja Testado em).

Escolha outra coisa se você precisar de um endpoint HTTP ao vivo com latência inferior a um segundo (este Actor é executado como jobs em lote, tipicamente de 5 a 60 s por página) ou de acesso confiável a sites atrás de proteção empresarial contra bots.

Para quem é?

Agentes de IA e aplicações LLM

• Dê olhos ao seu agente. Passe fileUrl para um modelo de visão para verificar um layout, ler um gráfico ou confirmar que uma página mudou.
• Previsível e seguro para automatizar. Cada URL recebe exatamente um registro por formato com status e errorType, e nada é cobrado por falhas.

QA, verificações de release e monitoramento

• Regressão visual e capturas de tela de release em desktop, tablet e celular em resolução retina (celular é tamanho iPhone a 3x).
• Agende (por exemplo, todas as manhãs) com um fileNamePrefix fixo para comparar páginas ao longo do tempo, ou capture apenas um componente com captureSelector.

Arquivamento e conformidade

• PDFs ou imagens de página inteira com o título da página, URL final, status HTTP e horário da captura, o que funciona bem como evidência do que uma página exibiu e quando. Use pdfMediaType: "print" para PDFs de artigos limpos, ou pdfSinglePage: true para uma página longa sem quebras de página.

Pipelines de relatórios e SEO

• Páginas de concorrentes, landing pages e dashboards capturados em lotes, vinculados diretamente do conjunto de dados para Sheets, Slack ou um relatório.

Correções para as reclamações mais comuns sobre ferramentas de captura de tela

Reclamação comum (avaliações/problemas do Apify, fóruns de API de captura de tela)	O que este Actor faz
"O popup de cookies cobre o conteúdo"	Clica em Aceitar em cerca de 20 plataformas de consentimento (OneTrust, Didomi, Sourcepoint, Quantcast, Cookiebot, Usercentrics, TrustArc, Google Funding Choices, iubenda, CookieYes...) ou em um botão de aceitar em 18 idiomas, depois oculta o que sobrar.
"Barra de navegação fixa repetida por toda a imagem de página inteira"	stickyElements: "static" exibe cabeçalhos uma vez no topo; "hide" os remove.
"Imagens/miniaturas ausentes" (lazy loading)	Rola a página em etapas com pausas curtas, continua enquanto a página cresce (limitado por maxScrollHeight), promove imagens data-src/loading=lazy, aguarda por elas e então retorna ao topo.
"Seções animadas ficam em branco" (fade-in na rolagem)	Distribui a página inteira em um viewport alto para que cada gatilho de rolagem dispare, depois avança animações CSS/JS para seu quadro final (freezeAnimations, ativado por padrão).
"O final de páginas longas fica em branco"	Pinta seções content-visibility, não quebra a rolagem do body e costura tiles acima do limite de captura única de ~16k pixels do Chrome.
"Emoji aparecem como caixas", texto CJK ausente	Inclui Noto Color Emoji, Noto CJK e fontes principais.
"Não consigo definir a altura / capturar apenas o topo"	fullPage: false, um width/height personalizado, maxHeight ou captureSelector para um elemento.
"Carregando para sempre / execução travada"	Esperas limitadas em cada etapa, um timeout rígido por URL e reinício do navegador após uma falha. Um anúncio lento não consegue travar a execução.
"Não funcionou e ainda assim usou meus créditos"	Apenas capturas reais são cobradas. Páginas de erro, muros de bots, renderizações em branco e timeouts são gratuitos e vêm com uma dica de correção.
"Muito lento quando só preciso do topo da página"	O fastMode: true opcional pula a rolagem passo a passo e a costura de tiles. Em um teste local (19 de out. de 2026, 5 sites, uma página por vez) levou 22 s em vez de 49 s.
"Lento e caro"	Sem surpresa de memória por execução: um preço fixo por arquivo, anúncios/rastreadores bloqueados e páginas paralelas dimensionadas para a memória da execução.

Exemplo de entrada

{
    "urls": ["https://apify.com", "https://www.theguardian.com/international"],
    "formats": ["png", "pdf"],
    "device": "mobile",
    "dismissCookieBanners": true,
    "stickyElements": "static",
    "maxHeight": 20000
}

Todas as opções estão na aba Input. Elas incluem waitUntil, waitForSelector, delayMs, captureSelector, hideSelectors, customCss, darkMode, headers, cookies, as opções de PDF (pdfFormat, pdfLandscape, pdfMargin, pdfMediaType, pdfSinglePage), captureErrorPages, captureBlockedPages, retryBlockedWithProxy, freezeAnimations, fastMode, maxScrollHeight, timeouts, tentativas e proxy.

Exemplo de saída

{
    "url": "https://www.theguardian.com/international",
    "status": "success",
    "format": "png",
    "fileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/0000-www.theguardian.com-international.png?signature=...",
    "key": "0000-www.theguardian.com-international.png",
    "contentType": "image/png",
    "bytes": 17235046,
    "width": 1440,
    "height": 22664,
    "pageHeight": 22664,
    "truncatedAtMaxHeight": false,
    "device": "desktop",
    "title": "News, sport and opinion from the Guardian's global edition | The Guardian",
    "finalUrl": "https://www.theguardian.com/international",
    "httpStatus": 200,
    "cookieBannerDismissed": true,
    "cookieBannerMethod": "known:button.sp_choice_type_11",
    "errorType": null,
    "charged": true,
    "capturedAt": "2026-10-19T00:30:00.000Z"
}

Uma URL com falha se parece com {"url": "https://www.nytimes.com/", "status": "failed", "errorType": "BLOCKED", "hint": "The site served a bot check. Retry with proxyConfiguration ...", "charged": false}.

Tipos de erro: INVALID_URL, BLOCKED, HTTP_ERROR, DNS_ERROR, CONNECTION_ERROR, TLS_ERROR, TIMEOUT, SELECTOR_NOT_FOUND, BLANK_PAGE, BROWSER_CRASH, REDIRECT_LOOP, NETWORK_ERROR, SPENDING_LIMIT.

Quanto custa capturar capturas de tela de sites?

Pague por evento. Você paga apenas pelos arquivos que foram entregues, sem cobrança separada pelo uso da plataforma Apify. Os preços diminuem conforme o seu plano Apify.

Evento	Gratuito	Bronze	Prata	Ouro e acima
Execução iniciada (uma vez por execução)	$0,01	$0,01	$0,01	$0,01
Captura de tela (arquivo PNG, JPEG ou WebP)	$0,008	$0,007	$0,006	$0,005
Arquivo PDF	$0,012	$0,012	$0,012	$0,012

Exemplos de custo (plano Gratuito):

• 1 captura de tela: $0,018 ($0,01 de início de execução + $0,008).
• 100 capturas de página inteira em uma execução: $0,81.
• 1.000 capturas de tela em uma execução: $8,01 ($5,01 no plano Ouro).
• 1.000 URLs como PNG e PDF: $20,01.

URLs com falha, bloqueadas, em branco e ignoradas não custam nada. Cada formato solicitado é um arquivo separado, e cada arquivo é cobrado uma vez. Para limitar uma execução, defina Custo máximo por execução (maxTotalChargeUsd). O Actor para de forma limpa antes do limite e marca as URLs restantes como SPENDING_LIMIT. O crédito gratuito mensal de $5 da Apify cobre aproximadamente 600 capturas de tela no plano Gratuito quando você agrupa URLs em poucas execuções. O tráfego de proxy, incluindo proxy residencial se você ativá-lo, está incluído nesses preços.

Testado em

Cloud QA, 18 de outubro de 2026, build 1.0.13 (o código de captura da build atual), configurações padrão (4 GB, sem proxy definido):

• Desktop: 28 de 39 URLs capturadas, comprimento total até o padrão de 36.000 px (React, Vercel, Linear, Figma, Notion, Airbnb, Amazon, Apple, Stripe, The Guardian, BBC, Le Monde, Spiegel, Corriere, nu.nl, Zillow, Baidu, Yahoo Japan, Naver, Wikipédia em russo e inglês, Al Jazeera, Hacker News, GitHub, USA.gov, getemoji.com, Shopify, httpbin). Páginas longas voltaram inteiras: Spiegel 32.257 px, Al Jazeera 26.568 px, getemoji.com 23.770 px, The Guardian 21.788 px. Recusadas corretamente e não cobradas: 8 barreiras antibot (Unsplash, Medium, El País, Zeit, NYTimes, WSJ, G2, FT; cada uma repetida uma vez via Apify Proxy), Indeed (conexão recusada), um domínio inexistente e uma página 404. El País e Medium passam em algumas execuções e não em outras (as barreiras antibot variam por IP); El País foi capturado com 20.971 px em uma nova verificação.
• Mobile (iPhone, 3x): 28 de 39 capturadas, incluindo El País. Zillow, Medium e as mesmas barreiras antibot fortes bloquearam esta execução; nenhuma foi cobrada.
• Opções: todos os 4 formatos em uma execução, PDF Letter/paisagem/impressão, PDF de página única, captura de elemento, espera por seletor, modo escuro, viewport de tablet, tamanho personalizado e escala 2x, cabeçalhos e cookies personalizados, seletores ocultos, CSS personalizado, prefixo de nome de arquivo, captura de página de erro e corte por altura máxima funcionaram como esperado; URLs inválidas, um erro de DNS e um HTTP 500 falharam com o tipo de erro correto e não foram cobrados; um certificado TLS expirado e uma resposta lenta de 60 s foram capturados.
• Verificação de cobrança: em todas as execuções de QA, os arquivos cobrados pela Apify corresponderam aos arquivos entregues.

Perguntas frequentes

Por quanto tempo os links dos arquivos funcionam? fileUrl é um link assinado para o armazenamento chave-valor da execução, e qualquer pessoa com o link pode abri-lo, sem necessidade de token. O armazenamento padrão da execução é mantido por 7 dias no plano Gratuito da Apify e por mais tempo nos planos pagos. Para manter os arquivos indefinidamente, renomeie (name) o armazenamento chave-valor da execução ou copie os arquivos para o seu próprio armazenamento com uma integração.

É possível capturar páginas atrás de login? Sim, se você passar o cookies da sessão (ou um cabeçalho Authorization). Capture apenas páginas que você tem permissão para acessar.

Por que um site falhou com BLOCKED? Alguns sites bloqueiam IPs de nuvem/data center. Por padrão, o Actor repete uma URL bloqueada uma vez via Apify Proxy (data center) com um contexto de navegador novo (retryBlockedWithProxy, ativado por padrão; ignorado quando você define seu próprio proxy). Se ainda estiver bloqueada, repita com "proxyConfiguration": {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}. Isso ajuda em alguns sites, mas não em todos: nos nossos testes de outubro de 2026, as barreiras antibot mais fortes (WSJ, G2, Zillow, Indeed, FT) ainda bloqueavam IPs residenciais. As tentativas bloqueadas não são cobradas por este Actor.

Ele captura sites HTTPS com erros de certificado? Sim. Erros de certificado são ignorados, então sites de staging expirados ou autoassinados ainda podem ser capturados.

Páginas muito longas? Páginas inteiras de até 36.000 pixels de dispositivo são capturadas por padrão (no desktop, isso comporta um artigo completo da Wikipédia em inglês de cerca de 26.000 px ou a página inicial do Spiegel de cerca de 32.500 px). Aumente maxHeight até 50.000 px CSS, ou diminua para limitar o tamanho do arquivo; WebP é limitado a 16.383 px. O tempo limite por URL é estendido automaticamente para páginas muito altas. Use JPEG para arquivos menores: a página inicial do Guardian com 22.664 px tinha 17 MB como PNG e 2,8 MB como JPEG no nosso teste.

Existe um modo mais rápido? Sim. Defina "fastMode": true. Ele pula a rolagem lenta que carrega imagens preguiçosas e dispara animações de rolagem, e faz uma única captura de página inteira em vez de emendar blocos. Barreiras de cookies, popups e cabeçalhos fixos ainda são tratados, e o preço é o mesmo. A contrapartida: imagens que só carregam ao rolar podem ficar em branco (no stripe.com, várias imagens abaixo da dobra estavam faltando), e as páginas são cortadas em 16.000 pixels de dispositivo (getemoji.com: 16.000 px em vez de 23.770 px, com truncatedAtMaxHeight: true). Teste local, 19 de outubro de 2026, mesmas 5 URLs como PNG: example.com 0,8 s vs 2,8 s, apify.com 6,9 s vs 14,0 s, Wikipédia 1,9 s vs 4,7 s, stripe.com 4,2 s vs 13,3 s. Mantenha o padrão para arquivamento e QA visual.

É legal? Capturar páginas publicamente visíveis geralmente é permitido, mas você é responsável por como usa as imagens (direitos autorais, dados pessoais, termos de serviço). Não use para capturar conteúdo que você não tem o direito de acessar.

Algo quebrou? Abra uma issue na aba Issues com a URL e o ID da execução. As correções geralmente são publicadas em poucos dias.

Schema de entrada do Actor

urls (tipo: array):

Páginas web a capturar. Cada URL gera um arquivo por formato. https:// é adicionado se estiver faltando; duplicatas são removidas e entradas inválidas são reportadas gratuitamente. Exemplo: ["https://apify.com", "example.com/pricing"]

formats (tipo: array):

Formatos de saída por URL: "png", "jpeg", "webp" (capturas de tela) e/ou "pdf". Cada formato é um arquivo e uma cobrança separados. Padrão: ["png"]. Exemplo: ["webp", "pdf"]

fullPage (tipo: boolean):

Capturar a página inteira rolável (true) ou apenas a primeira tela/viewport (false). Padrão: true. Exemplo: false para uma miniatura rápida da parte acima da dobra.

fastMode (tipo: boolean):

Troque completude por velocidade. Pula a rolagem lenta que carrega imagens preguiçosas e animações de rolagem, e faz uma única captura de página inteira (até 16.000 px de dispositivo) em vez de emendar blocos, então páginas muito longas são cortadas e imagens abaixo da dobra podem estar faltando. Barreiras de cookies, popups e cabeçalhos fixos ainda são tratados. Mesmo preço. Exemplo: true

device (tipo: string):

Predefinição de viewport: "desktop" (1440x900), "desktop-hd" (1920x1080), "laptop" (1280x800), "tablet" (820x1180 @2x) ou "mobile" (iPhone 390x844 @3x, user agent mobile). Padrão: "desktop". Exemplo: "mobile"

width (tipo: integer):

Largura de viewport personalizada em pixels CSS; substitui a largura da predefinição. Exemplo: 1366

height (tipo: integer):

Altura de viewport personalizada em pixels CSS; substitui a predefinição. Com fullPage false, esta é a altura da imagem. Exemplo: 768

deviceScaleFactor (tipo: integer):

Densidade de pixels (1-3). 2 ou 3 gera imagens nítidas em retina, mas arquivos maiores. Padrão: da predefinição (desktop 1, mobile 3). Exemplo: 2

maxHeight (tipo: integer):

Parte mais longa da página a capturar, em pixels CSS. Deixe vazio para o padrão: a página inteira até 36.000 pixels de dispositivo (36.000 px no desktop, 18.000 no tablet, 12.000 no mobile), o que cobre quase toda página real, incluindo primeiras páginas de notícias muito longas e listas da Wikipédia. Páginas mais longas são cortadas aqui e sinalizadas com truncatedAtMaxHeight: true. Máximo 50.000 (PNG/JPEG também são limitados a 60.000 pixels de dispositivo, WebP a 16.383). Exemplo: 8000 para arquivos menores e mais rápidos.

quality (tipo: integer):

Qualidade JPEG/WebP, 1-100. Ignorado para PNG e PDF. Padrão: 80. Exemplo: 60 para arquivos menores.

waitUntil (tipo: string):

Quando a página conta como carregada: "domcontentloaded" (mais rápido), "load" (padrão, espera até 15 s por imagens) ou "networkidle" (mais lento, para aplicações de página única pesadas). Exemplo: "networkidle"

waitForSelector (tipo: string):

Espere até que este seletor CSS esteja visível antes de capturar (até navigationTimeoutSecs). Use para aplicações que renderizam dados tarde. Falha como SELECTOR_NOT_FOUND (não cobrado) se nunca aparecer. Exemplo: "#main-chart"

captureSelector (tipo: string):

Capturar apenas este elemento em vez da página (somente capturas de tela). Falha como SELECTOR_NOT_FOUND (não cobrado) se estiver ausente. Exemplo: "article", "#pricing-table"

delayMs (tipo: integer):

Espera extra em milissegundos após o carregamento e antes de capturar, para animações ou widgets tardios. Máximo 60000. Padrão: 0. Exemplo: 2000

scrollToBottom (tipo: boolean):

Rolar pela página em etapas (com pausas curtas) para que imagens preguiçosas, seções acionadas por rolagem e conteúdo carregado ao rolar apareçam; continua enquanto a página cresce (limitado), depois volta ao topo. Padrão: true. Exemplo: false para capturas mais rápidas de páginas curtas.

freezeAnimations (tipo: boolean):

Colocar animações CSS, transições e efeitos de revelação por rolagem (fade-ins, slide-ins, cards animados) em seu estado final, para que a captura de tela mostre a página finalizada em vez de seções meio desbotadas ou vazias. Padrão: true. Exemplo: false para capturar a página exatamente no meio da animação.

dismissCookieBanners (tipo: boolean):

Clicar em "Aceitar" em banners de cookies/consentimento (cerca de 20 plataformas como OneTrust, Didomi, Sourcepoint, Cookiebot e Usercentrics, além de botões de aceitar em 18 idiomas) e ocultar o que sobrar. Padrão: true. Exemplo: false para capturar o próprio banner.

hidePopups (tipo: boolean):

Ocultar popups de newsletter, sobreposições de tela cheia e widgets de chat (Intercom, Drift, HubSpot, Zendesk e outros). Padrão: true.

stickyElements (tipo: string):

Como tratar cabeçalhos fixos/sticky em capturas de página inteira: "static" (mostrar uma vez no topo, padrão), "hide" (removê-los) ou "keep" (deixar como o navegador os desenha; pode repetir). Exemplo: "hide"

hideSelectors (tipo: array):

Seletores CSS de elementos a ocultar antes de capturar. Exemplo: [".ad-slot", "#promo-bar"]

customCss (tipo: string):

CSS injetado antes de capturar. Exemplo: "body { font-size: 18px } .banner { display: none }"

headers (tipo: object):

Cabeçalhos HTTP extras enviados com cada requisição (Host, Content-Length e similares são ignorados). Exemplo: {"Accept-Language": "de-DE", "Authorization": "Bearer abc"}

cookies (tipo: array):

Cookies definidos antes do carregamento, para páginas com login ou específicas de região. Cada um precisa de name e value; o domain assume o host da URL por padrão. Exemplo: [{"name": "session", "value": "abc123", "domain": ".example.com"}]

darkMode (tipo: boolean):

Emular o esquema de cores escuro (prefers-color-scheme: dark). Só altera sites que suportam modo escuro. Padrão: false.

blockAds (tipo: boolean):

Bloquear hosts comuns de anúncios e rastreamento. Capturas mais rápidas e limpas. Padrão: true.

pdfFormat (tipo: string):

Tamanho do papel do PDF: "A4" (padrão), "Letter", "Legal", "A3" ou "Tabloid". Exemplo: "Letter"

pdfLandscape (tipo: boolean):

Páginas de PDF em paisagem. Padrão: false.

pdfMargin (tipo: string):

Margem da página do PDF em todos os lados, em unidades CSS. Padrão: "10mm". Exemplo: "0" ou "0.5in"

pdfPrintBackground (tipo: boolean):

Incluir cores e imagens de fundo nos PDFs. Padrão: true.

pdfMediaType (tipo: string):

Mídia CSS para PDFs: "screen" (parece com o site, padrão) ou "print" (usa a folha de estilo de impressão do site, geralmente mais limpa para artigos). Exemplo: "print"

pdfSinglePage (tipo: boolean):

Faça o PDF ter uma única página longa com a altura total da página e sem quebras de página, como uma captura de tela de página inteira em formato vetorial. Padrão: false.

captureErrorPages (type: boolean):

Capture e cobre páginas que retornam HTTP 4xx/5xx (por exemplo, para documentar um 404). Padrão: false, então páginas de erro falham como HTTP_ERROR e não são cobradas.

captureBlockedPages (type: boolean):

Capture e cobre páginas de verificação/desafio de bot (Cloudflare, DataDome...) em vez de falhar como BLOCKED. Padrão: false, então páginas bloqueadas não são cobradas.

retryBlockedWithProxy (type: boolean):

Quando um site responde com uma verificação de bot e você não configurou seu próprio proxy, tente novamente essa URL uma vez pelo Apify Proxy (datacenter) com um navegador regular e novo. Páginas bloqueadas nunca são cobradas, independentemente de a nova tentativa funcionar. Padrão: true. Exemplo: false para falhar rapidamente em sites bloqueados.

navigationTimeoutSecs (type: integer):

Segundos para aguardar o início do carregamento da página e o waitForSelector. Padrão: 45. Exemplo: 90 para sites lentos.

pageTimeoutSecs (type: integer):

Limite de tempo em segundos para uma URL (carregamento, rolagem e captura). Deixe vazio para 120 s, ou até 240 s automaticamente em execuções com menos de 4 GB de memória (menos de 1 vCPU). Páginas muito altas recebem automaticamente tempo extra (até +120 s) assim que sua altura é conhecida.

maxRetries (type: integer):

Novas tentativas para erros temporários (timeouts, rede, travamentos, páginas em branco). Erros de DNS, HTTP e de seletor não são repetidos. Padrão: 1. Exemplo: 2

maxConcurrency (type: integer):

Quantas páginas carregar em paralelo. Deixe vazio para automático: 1 abaixo de 2 GB de memória, 2 com 2–4 GB, depois 1 por 2 GB (4 com 8 GB, máx. 8). Novas páginas também aguardam enquanto a memória estiver acima de 70% ou a CPU estiver saturada, e apenas uma página muito alta por vCPU é renderizada por vez.

perHostConcurrency (type: integer):

Máximo de páginas em paralelo no mesmo site, para manter a cortesia e evitar limites de taxa. Padrão: 2.

proxyConfiguration (type: object):

Proxy para todas as requisições. Não é necessário para a maioria dos sites; para sites que bloqueiam data centers, use o Apify residential proxy. Exemplo: {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}

fileNamePrefix (type: string):

Prefixo para as chaves de arquivo no key-value store. Exemplo: "release-42" gera chaves como "release-42-0000-example.com.png"

Exemplo de objeto de entrada do Actor

{
  "urls": [
    "https://apify.com",
    "https://en.wikipedia.org/wiki/Web_scraping"
  ],
  "formats": [
    "png"
  ],
  "fullPage": true,
  "fastMode": false,
  "device": "desktop",
  "quality": 80,
  "waitUntil": "load",
  "delayMs": 0,
  "scrollToBottom": true,
  "freezeAnimations": true,
  "dismissCookieBanners": true,
  "hidePopups": true,
  "stickyElements": "static",
  "headers": {},
  "cookies": [],
  "darkMode": false,
  "blockAds": true,
  "pdfFormat": "A4",
  "pdfLandscape": false,
  "pdfMargin": "10mm",
  "pdfPrintBackground": true,
  "pdfMediaType": "screen",
  "pdfSinglePage": false,
  "captureErrorPages": false,
  "captureBlockedPages": false,
  "retryBlockedWithProxy": true,
  "navigationTimeoutSecs": 45,
  "maxRetries": 1,
  "perHostConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Esquema de saída do Actor

captures (type: string):

Registros de sucesso e falha: fileUrl, status, format, width/height, pdfPages, errorType.

files (type: string):

Todos os arquivos PNG/JPEG/WebP/PDF desta execução.

summary (type: string):

Contagens de URLs bem-sucedidas, com falha e ignoradas, tipos de erro e eventos cobrados.

API

Você pode executar este Actor programaticamente usando nossa API. Abaixo estão exemplos de código em JavaScript, Python e CLI, bem como a especificação OpenAPI e a configuração do servidor MCP.

Exemplo em JavaScript

import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com",
        "https://en.wikipedia.org/wiki/Web_scraping"
    ],
    "headers": {},
    "cookies": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("catalyst-labs/website-screenshot-pdf-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

Exemplo em Python

from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": [
        "https://apify.com",
        "https://en.wikipedia.org/wiki/Web_scraping",
    ],
    "headers": {},
    "cookies": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("catalyst-labs/website-screenshot-pdf-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

Exemplo em CLI

echo '{
  "urls": [
    "https://apify.com",
    "https://en.wikipedia.org/wiki/Web_scraping"
  ],
  "headers": {},
  "cookies": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call catalyst-labs/website-screenshot-pdf-api --silent --output-dataset

Configuração do servidor MCP

{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,catalyst-labs/website-screenshot-pdf-api"
        }
    }
}

O servidor hospedado faz seu login com OAuth na primeira conexão, então nenhum token de API deve estar nesta configuração. Clientes sem suporte a OAuth podem enviar um cabeçalho Authorization: Bearer <APIFY_API_TOKEN> em vez disso, usando um token de API & Integrations no Apify Console (https://console.apify.com/settings/integrations).

Especificação OpenAPI

Baixe a definição OpenAPI: https://api.apify.com/v2/actors/Q0IjIMqCA5OnecDNj/builds/hwhtQ8ZfwCzhJ2pAQ/openapi.json