DeepSeek Scraper API: Capture Respostas, Raciocínio e Fontes como JSON

TL;DR:

• O ator scraper.deepseek envia um prompt para o DeepSeek e retorna a resposta como JSON. Duas entradas obrigatórias — prompt e country — vão para dentro; um objeto task_result com 21 campos retorna, incluindo o markdown renderizado, o html bruto e uma contagem de tokens.
• A trilha de raciocínio está no payload, não escondida por trás dele. Envie thinking: true e a resposta ganha um fragmento THINK que traz o texto de planejamento passo a passo do DeepSeek, além dos segundos que passou nisso.
• Duas flags Boolean alteram a forma da resposta, não apenas seu conteúdo. thinking e search cada uma adiciona tipos de fragmento; enviar ambos muda o DeepSeek para uma sequência agente que busca, abre páginas individuais e replaneja entre etapas.
• Chaves de entrada desconhecidas são aceitas e descartadas sem comentários. web_search, thinking_enabled, search_enabled, e model todos retornam HTTP 201 e não mudam nada — enquanto uma chave corretamente nomeada com o tipo errado retorna 400. Transfira um script de captura de outro ator e suas flags desaparecem no caminho.
• Citações chegam em três codificações diferentes, dependendo das flags que você enviou. O modo de busca simples usa marcadores [citation:N] contra um cite_index; o modo agente usa marcadores [reference:N] contra um array de ponteiros de referência baseado em zero. Este guia mostra como resolver ambos.
• Grátis para começar. Novas contas Scrapeless incluem créditos de teste gratuitos — inscreva-se em app.scrapeless.com.

Introdução: a resposta é apenas metade do payload

Pesquise por uma API de raspagem DeepSeek e quase tudo o que você encontra está sobre direcionar o modelo DeepSeek para HTML que você já baixou. Essa é uma técnica real, e a Scrapeless cobre isso no guia de raspagem da web DeepSeek. Este guia segue na outra direção: DeepSeek é a fonte, e os dados que você deseja são o que DeepSeek diz quando alguém lhe faz uma pergunta.

Esses dados são importantes pela mesma razão que as respostas do ChatGPT e do Gemini são importantes. Quando um comprador pergunta a um assistente qual ferramenta escolher, a resposta e as páginas por trás dela são um sinal de mercado. O DeepSeek adiciona duas coisas que os outros assistentes não entregam tão prontamente: uma trilha de raciocínio exposta e — quando você ativa ambas as flags de capacidade — um registro visível de quais páginas ele escolheu abrir e ler na íntegra.

O ator scraper.deepseek transforma tudo isso em duas chamadas HTTP: uma para enviar o prompt, uma para coletar o resultado. Este guia cobre a forma do pedido, o esquema completo da resposta capturado de execuções ao vivo, um cliente Python executável e a lógica de resolução de citações que o payload requer e não documenta.

O Que Você Pode Fazer Com Isso

• Acompanhe como o DeepSeek descreve sua categoria. Execute um conjunto fixo de prompts em uma programação e armazene a resposta markdown além das fontes por trás dela.
• Capture o raciocínio por trás da conclusão. O fragmento THINK mostra como o DeepSeek formulou a pergunta antes de responder — útil quando você se importa com o porquê de um produto ter sido recomendado.
• Meça a participação da citação. No modo de busca, o payload carrega cada fonte que o DeepSeek recuperou, com título, URL, nome do site e timestamp de publicação.
• Separe as páginas que o DeepSeek abriu daquelas que ele apenas listou. No modo agente, fragmentos TOOL_OPEN registram as URLs específicas que ele leu de cabo a rabo — um conjunto muito mais restrito do que os resultados da busca.
• Compare mercados. country fixa a saída da execução, para que o mesmo prompt possa ser capturado para várias regiões e comparado.
• Construa conjuntos de dados de respostas. Prompt, resposta, raciocínio e fontes chegam como um único objeto JSON por execução, prontos para armazenar.

Por Que o Raspador DeepSeek da Scrapeless

O ator scraper.deepseek pertence à família LLM Chat Scraper dentro da linha da API de Raspagem Universal:

• Um prompt entra, resposta estruturada sai. O manuseio de login e a reestruturação de streaming acontecem do lado do servidor, então você nunca toca em uma interface que não foi construída para ser analisada.
• O fluxo do fragmento é preservado. Raciocínios, consultas de busca, páginas abertas e a resposta final chegam como objetos tipados separados em vez de uma única string achatada.
• Saída residencial fixada por país. Execuções passam por proxies residenciais em mais de 195 países; a entrada country necessária é toda a configuração.
• Um contrato em toda a família. O endpoint, o cabeçalho x-api-token e o fluxo de enviar-então-coletar são idênticos para os atores ChatGPT, Gemini, Perplexity, Copilot e Grok.
  Uma nota sobre a documentação: o início rápido do LLM Chat Scraper documenta o fluxo de tarefa compartilhado e lista os outros atores da família, mas ainda não possui uma página DeepSeek. Cada campo e sinalizador descrito abaixo foi capturado de execuções ao vivo contra o ato, em vez de ser lido de uma página de referência.

Pré-requisitos

• Uma conta Scrapeless e chave de API — crie uma em app.scrapeless.com.
• curl e jq para a captura rápida, ou Python 3.10+ para o cliente.
• Familiaridade com HTTP e JSON.

Mantenha a chave no ambiente para que ela nunca chegue à sua árvore de código-fonte:

export SCRAPELESS_API_KEY=your_api_token_here

Como funciona a API DeepSeek Scraper

O ator é assíncrono. Você cria uma tarefa e depois a coleta.

• Enviar: POST https://api.scrapeless.com/api/v2/scraper/request → 201 com {"status": "pending", "task_id": "..."}
• Coletar: GET https://api.scrapeless.com/api/v2/scraper/result/{task_id} → 202 com {"status": "running"} enquanto a execução está em andamento, em seguida 200 com o resultado completo
• Cabeçalho de autenticação: x-api-token: $SCRAPELESS_API_KEY

O 202 está fazendo exatamente o trabalho que a especificação semântica HTTP define para ele: a solicitação foi aceita, o processamento não está completo, e o resultado vive em um local separado. Consulte esse local em um intervalo fixo até que ele responda 200. Resultados concluídos são mantidos por cinco minutos, então colete prontamente ou registre um webhook em vez disso.

Parâmetros da solicitação

Ambos os campos necessários são validados ao enviar. Omitir country retorna 400 com Key: 'deepseekParam.Country' Error:Field validation for 'Country' failed on the 'required' tag; omitir prompt retorna a mensagem correspondente para Prompt. Os códigos de país seguem o padrão ISO 3166-1 alpha-2.

Captura rápida com curl

Envie a tarefa, consulte-a até a conclusão e imprima o resumo estrutural:

TASK_ID=$(curl -sS -X POST https://api.scrapeless.com/api/v2/scraper/request \
  -H "Content-Type: application/json" \
  -H "x-api-token: ${SCRAPELESS_API_KEY}" \
  -d '{
    "actor": "scraper.deepseek",
    "input": {"prompt": "Explain how HTTP caching headers work.", "country": "US"}
  }' | jq -r '.task_id')
echo "task_id=${TASK_ID}"

for _ in $(seq 1 60); do
  BODY=$(curl -sS -H "x-api-token: ${SCRAPELESS_API_KEY}" \
    "https://api.scrapeless.com/api/v2/scraper/result/${TASK_ID}")
  echo "${BODY}" | jq -e '.status == "success"' >/dev/null 2>&1 && break
  sleep 4
done

echo "${BODY}" | jq -r '"status=" + .status,
  "fragments=" + ([.task_result.fragments[].type] | join(",")),
  "answer_chars=" + (.task_result.markdown | length | tostring),
  "tokens=" + (.task_result.accumulated_token_usage | tostring)'

O envelope da resposta

Uma chamada de coleta concluída retorna um documento JSON simples, bem dentro do que o padrão de formato de intercâmbio JSON define, com duas chaves de nível superior: status e task_result.

// illustrative sample — every key and type below is from live scraper.deepseek runs; long strings abridged
{
  "status": "success",
  "task_result": {
    "markdown": "To handle caching, an HTTP response carries…",
    "html": "<p class=\"ds-markdown-paragraph\">…</p>",
    "fragments": [
      {"type": "RESPONSE", "id": 2, "stage_id": 1, "content": "To handle caching…", "references": []}
    ],
    "accumulated_token_usage": 637,
    "thinking_enabled": false,
    "search_enabled": false,
    "search_triggered": false,
    "status": "FINISHED",
    "quasi_status": "FINISHED",
    "role": "ASSISTANT",
    "message_id": 2,
    "parent_id": 1,
    "conversation_mode": "DEFAULT",
    "inserted_at": 1786037083.6987588,
    "model": "",
    "feedback": null,
    "incomplete_message": null,
    "auto_continue": false,
    "ban_edit": false,
    "ban_regenerate": false,
    "has_pending_fragment": false
  }
}

Campo por campo:

Trate model como indisponível em vez de como um campo a ser lido. Se precisar saber qual configuração produziu uma captura, registre os sinalizadores que você enviou junto com a resposta.

Obtenha sua chave de API no plano grátis: app.scrapeless.com

O fluxo de fragmentos é onde os detalhes vivem

fragments é o campo que separa este ator de uma captura de chat simples. Sua extensão e composição mudam com os flags que você envia:

Os tipos de fragmentos carregam diferentes chaves, que é a parte que quebra analisadores ingênuos:

• RESPONSE — content, id, stage_id, type, references. O content é a resposta com marcadores de citação ainda incorporados.
• THINK — as mesmas chaves mais elapsed_secs. No modo apenas de raciocínio, o rastreamento é um longo bloco; no modo agente, torna-se várias notas de planejamento curtas entre chamadas de ferramentas.
• SEARCH — queries (as cadeias de busca que o DeepSeek compôs), results (as fontes), status, e um content que é null. Não há stage_id.
• TOOL_SEARCH — o equivalente no modo agente de SEARCH, com um stage_id adicionado.
• TOOL_OPEN — reference (um ponteiro de volta para o fragmento de busca que revelou a URL) e um único objeto result para a uma página que foi aberta. Sem content, sem references.

Cada objeto fonte — em SEARCH.results, TOOL_SEARCH.results, e TOOL_OPEN.result — carrega as mesmas oito chaves: title, url, snippet, site_name, site_icon, published_at, query_indexes, e cite_index.

Uma execução agente capturada para este guia produziu 13 fragmentos: um plano inicial, um TOOL_SEARCH que executou quatro consultas e retornou 38 URLs únicas, oito fragmentos TOOL_OPEN para as páginas que o DeepSeek escolheu ler na íntegra, duas notas de planejamento adicionais e a resposta. O conjunto TOOL_OPEN é o mais interessante — aquelas oito URLs são o que o DeepSeek realmente leu, em contraste com as 38 que ele apenas viu.

O comportamento de raciocínio que isso expõe é a mesma capacidade descrita em o artigo de reforço DeepSeek-R1; a contribuição do ator é tornar o rastreamento disponível como um campo em vez de um painel renderizado.

Integrando a API em Python

Um cliente completo: enviar, consultar até a conclusão e indexar as fontes pelo número de citação.

# deepseek_client.py — submit a prompt to scraper.deepseek and collect the result
import os
import time

import requests

BASE = "https://api.scrapeless.com/api/v2/scraper"
HEADERS = {
    "Content-Type": "application/json",
    "x-api-token": os.environ["SCRAPELESS_API_KEY"],
}


def ask_deepseek(prompt, country="US", thinking=False, search=False, interval=4):
    created = requests.post(
        f"{BASE}/request",
        headers=HEADERS,
        json={
            "actor": "scraper.deepseek",
            "input": {
                "prompt": prompt,
                "country": country,
                "thinking": thinking,
                "search": search,
            },
        },
        timeout=60,
    )
    created.raise_for_status()
    task_id = created.json()["task_id"]

    while True:
        collected = requests.get(f"{BASE}/result/{task_id}", headers=HEADERS, timeout=120)
        if collected.status_code == 200:
            return collected.json()
        if collected.status_code != 202:
            raise RuntimeError(f"task {task_id} did not complete: {collected.text}")
        time.sleep(interval)


def sources_by_citation(result):
    """Every source the run produced, keyed by the cite_index used in the answer."""
    found = {}
    for fragment in result.get("fragments") or []:
        for source in fragment.get("results") or []:
            found[source.get("cite_index")] = source
        if fragment.get("result"):
            found[fragment["result"].get("cite_index")] = fragment["result"]
    return found


if __name__ == "__main__":
    payload = ask_deepseek(
        "What are the latest developments in fusion energy research?",
        search=True,
    )
    result = payload["task_result"]
    fragments = result.get("fragments") or []
    cited = sources_by_citation(result)
    print(f"status={payload['status']} search_triggered={result['search_triggered']}")
    print("fragments=" + ",".join(f.get("type", "?") for f in fragments))
    print(f"answer_chars={len(result['markdown'])} tokens={result['accumulated_token_usage']}")
    print(f"sources={len(cited)}")
    for index in sorted(k for k in cited if isinstance(k, int))[:3]:
        source = cited[index]
        print(f"  [citation:{index}] {source['site_name']} -> {source['url']}")

Uma execução capturada:

status=success search_triggered=True
fragments=SEARCH,RESPONSE
answer_chars=7664 tokens=926
sources=11
  [citation:1] Lawrence Livermore National Laboratory (.gov) -> https://lasers.llnl.gov/news/llnl-experts-help-advance-inertial-fusion-energy-us-ife-conference
  [citation:2] Reuters -> https://www.reuters.com/business/energy/fusion-energy-developer-tae-signs-helium-3-future-fuel-supply-option-agreement-2026-08-05/
  [citation:3] Oak Ridge National Laboratory (.gov) -> https://www.ornl.gov/news/oak-ridge-national-lab-cleveland-clinic-and-ibm-achieve-first-known-computations-fusion?utm_source=Sutor-Group-Intelligence-and-Advisory&utm_medium=daily-links&utm_campaign=Substack

Aquelas etiquetas [citation:N] são os mesmos marcadores incorporados no texto da resposta, então as linhas impressas já são um índice de citação funcional. Observe a terceira URL também — as URLs de origem chegam exatamente como o DeepSeek as encontrou, com os parâmetros de rastreamento de referência incluídos, então normalize antes de agrupar capturas por domínio ou deduplicá-las.

Alterar a chamada para thinking=True, search=True troca o fragmento plano SEARCH pela sequência agente e fornece o conjunto de páginas abertas em vez disso. Esse modo é onde o rastreamento de raciocínio reside, e também onde a carga útil é menos previsível — veja as próximas duas seções antes de se basear nisso.

Resolvendo citações

O DeepSeek marca suas fontes dentro do texto da resposta, e o formato do marcador depende de quais flags produziram a execução. Duas combinações de flags, três codificações entre elas, todas confirmadas contra capturas ao vivo:

Apenas busca. O fragmento RESPONSE's content carrega marcadores [citation:N], onde N corresponde ao campo cite_index nas entradas do fragmento SEARCH's results. O markdown de nível superior neste modo carrega uma segunda codificação das mesmas informações: esses marcadores já resolvidos em links Markdown inline. Um pipeline que só precisa de prosa legível pode ler markdown e pular toda a junção.

Pensando e buscando juntos. Os marcadores tornam-se [reference:N], e N é um índice baseado em zero para a matriz RESPONSE do fragmento references — não um cite_index. Cada entrada nessa matriz é um ponteiro de retorno da forma {"id": 5, "type": "TOOL_OPEN"} identificando o fragmento que forneceu a fonte. Neste modo, o markdown de nível superior é idêntico em bytes ao conteúdo RESPONSE, incluindo marcadores e tudo, então a junção é por sua conta.
A segunda situação tem um limite honesto que vale a pena saber antes de você construir um relatório sobre isso. Um TOOL_OPEN ponteiro de retrocesso se resolve de forma limpa, porque esse fragmento contém exatamente um result e, portanto, exatamente uma URL. Um TOOL_SEARCH ponteiro de retrocesso não se resolve — ele nomeia um fragmento que contém dezenas de resultados, então ele informa que a reivindicação veio da etapa de pesquisa sem especificar qual fonte. Em uma captura agentic, 45 de 69 referências apontaram para fragmentos TOOL_OPEN e se resolveram em URLs específicas; os 24 restantes apontaram para o fragmento de pesquisa como um todo. Observe também que cite_index é null em resultados dentro de fragmentos em modo agentic, então não pode ser usado como uma alternativa lá.

A consequência prática: se a atribuição de fonte por reivindicação é o resultado esperado, trabalhe apenas com search: true e use cite_index. Se você quer a trilha de raciocínio e a lista de páginas realmente abertas, trabalhe com ambas as flags e trate a vinculação de citação como parcial.

Problemas comuns de formato de dados

• Chaves de entrada desconhecidas são aceitas e ignoradas em silêncio. Enviar web_search: true, thinking_enabled: true, search_enabled: true ou model: "deepseek-reasoner" retornou todos 201 e produziu uma execução com a flag desmarcada e sem aviso em qualquer lugar na carga útil. Os nomes de trabalho são exatamente thinking e search. Uma chave nomeada corretamente com o tipo errado se comporta de forma diferente — thinking: "true" como uma string retorna 400 invalid params — então a API valida tipos nas chaves que reconhece e descarta as restantes. Se você estiver portando um script de captura do ChatGPT, sua flag web_search desaparecerá e cada resposta do DeepSeek voltará sem fontes.
• Um país não suportado falha na coleta, não na submissão. country: "ZZ" retorna um 201 normal com um task_id; a falha aparece na chamada de coleta como 400 com {"message": "execution failed", "status": "failed"}. Valide os códigos de país do seu lado em vez de ler o status de submissão como confirmação.
• markdown e o conteúdo RESPONSE nem sempre são a mesma string. No modo apenas de pesquisa markdown é mais longo, porque os marcadores de citação foram expandidos em links. Em todos os outros modos as duas correspondem. Escolha um campo e mantenha-se com ele.
• references não é uma lista de citações. É um array de {id, type} ponteiros de retrocesso, e está vazio, exceto no modo agentic. As fontes em si vivem nos fragmentos de pesquisa e abertos.
• Conjuntos de chaves de fragmentos diferem por tipo. SEARCH tem queries e results, mas não stage_id; TOOL_OPEN tem reference e um singular result, mas não content. Leia os fragmentos por type, nunca por posição.
• O modo agentic varia muito mais do que os modos planos. Execuções apenas de pesquisa voltaram como SEARCH, RESPONSE em cada captura feita para este guia. Com ambas as flags definidas, capturas consecutivas do mesmo prompt abriram 8, 15 e 13 páginas, o comprimento da resposta variou de 3.720 a 6.707 caracteres, e várias execuções foram diretamente de TOOL_SEARCH para RESPONSE sem abrir uma única página. Se seu pipeline precisa do conjunto de páginas abertas, trate uma página vazia como um resultado ordinário e leia a série em vez de uma única execução.
• Uma tarefa pode terminar em um estado falhado, e isso aparece na chamada de coleta. Uma minoria de execuções agentic terminou como falhadas em vez de bem-sucedidas; a chamada de coleta então responde 400 em vez de 200, exatamente como um país não suportado faz. O cliente acima verifica se há um 202 antes de continuar e eleva com o corpo em qualquer outra coisa, então o id da tarefa e a mensagem do servidor chegam aos seus logs. Trate uma tarefa falhada como um resultado gravado em seu conjunto de dados, não como algo a ser encoberto.

Atores acompanhantes

O endpoint, cabeçalho e fluxo de submeter-para-colecionar permanecem os mesmos em toda a família — apenas o nome do ator e suas entradas específicas da plataforma mudam:

• scraper.chatgpt — prompt mais country, com uma flag web_search própria.
• scraper.gemini — a mesma entrada de dois campos, retornando a resposta mais um array de citações.
• scraper.perplexity — country exigido e uma flag web_search; retorna resultados da web e prompts relacionados.
• scraper.grok — requer uma mode de raciocínio e retorna web aberta e citações X como arrays separados; coberto no guia da API do scraper Grok.
• scraper.copilot e scraper.alexa — as respostas de Copilot e Alexa aparecem sob o mesmo contrato.
  Porque cada ator nomeia suas bandeiras de maneira diferente, mantenha o construtor de entrada por ator, em vez de compartilhar um dicionário entre eles. O preço baseado em uso para a linha, com créditos de teste gratuitos na inscrição, está na página de preços.

Conclusão: duas chamadas e uma carga útil que vale a pena ler de perto

Capturar o DeepSeek envolve duas chamadas HTTP: POST { actor: "scraper.deepseek", input: { prompt, country } } para criar uma tarefa, e depois GET para obter o resultado até que ele responda 200. A resposta está em markdown. Tudo que torna o DeepSeek distinto — o traço de raciocínio, as consultas de busca, as páginas que ele abriu — está em fragments, e somente se você solicitou isso com thinking e search. Nomeie essas duas bandeiras exatamente, porque a API aceitará qualquer outra coisa que você enviar e ignorará silenciosamente.

Pronto para capturar as respostas do DeepSeek como dados?

Junte-se à nossa comunidade para reivindicar um plano gratuito e comparar anotações com desenvolvedores que estão construindo pipelines de respostas de IA: Discord · Telegram.

Inscreva-se em app.scrapeless.com para créditos de teste gratuitos e aponte scraper.deepseek para os prompts e mercados que seu programa de monitoramento cobre.

FAQ

Q: Como faço para autenticar uma solicitação da API do scraper DeepSeek?

Cada chamada carrega o cabeçalho x-api-token: <your key>, tanto na solicitação de envio quanto na de coleta. Uma chave de conta cobre scraper.deepseek e todos os outros atores do Scrapeless. Crie uma chave no plano gratuito em app.scrapeless.com.

Q: Por que a solicitação retorna um task_id em vez da resposta?

O ator é assíncrono, então um envio retorna 201 com {"status": "pending", "task_id": "..."} e a resposta chega a partir de uma segunda chamada para /api/v2/scraper/result/{task_id}. Esse endpoint retorna 202 com {"status": "running"} até que a execução termine, então 200 com o task_result completo. Os resultados concluídos são mantidos por cinco minutos; uma URL de webhook é a alternativa para polling.

Q: Como faço para obter o traço de raciocínio do DeepSeek?

Envie "thinking": true na entrada. A resposta então contém um fragmento THINK cujo content é o texto de raciocínio e cujo elapsed_secs é o tempo gasto nele. Sem essa bandeira, o raciocínio não é gerado e thinking_enabled retorna false.

Q: O scraper DeepSeek retorna fontes e citações?

Sim, quando você envia "search": true. As fontes chegam como objetos com title, url, snippet, site_name, site_icon, published_at, query_indexes e cite_index, anexadas ao fragmento SEARCH ou TOOL_SEARCH. Sem a bandeira, nenhuma fonte é recuperada e a resposta é gerada apenas pelo modelo.

Q: Por que meu parâmetro web_search não está tendo efeito?

Porque esse é o nome do parâmetro do ator ChatGPT. A bandeira do DeepSeek é search, e chaves desconhecidas são aceitas com um 201 e descartadas sem erro. O mesmo se aplica a thinking_enabled, search_enabled e model — use exatamente thinking e search.

Q: Quais campos estão vazios ou podem ser nulos?

model retornou como uma string vazia em cada execução capturada para este guia, feedback e incomplete_message são null em execuções concluídas, e references está vazio a menos que a execução tenha usado ambas as bandeiras. search_triggered permanece false quando search não foi solicitado. Leia de forma defensiva e trate campos ausentes como ausentes em vez de como falhas.

Q: Posso rodar isso sem um SDK?

Sim. É HTTP puro — curl, Python requests, Node fetch, ou qualquer cliente que possa enviar um POST JSON e um GET com um cabeçalho.

Q: Capturar respostas do DeepSeek é legal?

O ator captura conteúdo de resposta gerado publicamente, mas as regras variam de acordo com a jurisdição e os termos de serviço de cada plataforma. Revise os termos aplicáveis e consulte um advogado para seu caso de uso, particularmente antes de redistribuir capturas, e não colete dados pessoais protegidos sob o GDPR ou CCPA. Quando seu pipeline buscar as URLs de origem que o DeepSeek cita, honre as diretrizes do crawler padronizadas pelo Protocolo de Exclusão de Robôs em cada um desses sites também.