Extrator de Web

Obter URLs para o contexto

Para tarefas envolvendo cálculos matemáticos ou análise de dados, adicione code_interpreter Ao lado do extrator da web para melhorar a precisão.

Começando.

Chame o extrator através da API Responses para resumir uma página web. Os exemplos abaixo usam web_search e web_extractor com qwen3.8-max em modo de pensar.

Python

```python {15}
import os
from openai import OpenAI

client = OpenAI(
  # If the environment variable is not configured, replace with: api_key="sk-xxx"
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1"
)

response = client.responses.create(
  model="qwen3.8-max",
  input="Please visit the official QwenCloud documentation, find the code interpreter topic and summarize it",
  tools=[
    {"type": "web_search"},
    {"type": "web_extractor"}
  ],
  extra_body={
    "enable_thinking": True
  }
)

# Uncomment to view intermediate output
# print(response.output)
print("=" * 20 + "Response" + "=" * 20)
print(response.output_text)

# Print tool invocation count
usage = response.usage
print("=" * 20 + "Tool Invocation Count" + "=" * 20)
if hasattr(usage, 'x_tools') and usage.x_tools:
  print(f"Web Extractor invocations: {usage.x_tools.get('web_extractor', {}).get('count', 0)}")
```

Node.js

```javascript {16}
import OpenAI from "openai";
import process from 'process';

const openai = new OpenAI({
  // If the environment variable is not configured, replace with: apiKey: "sk-xxx"
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
});

async function main() {
  const response = await openai.responses.create({
    model: "qwen3.8-max",
    input: "Please visit the official QwenCloud documentation, find the code interpreter topic and summarize it",
    tools: [
      { type: "web_search" },
      { type: "web_extractor" }
    ],
    enable_thinking: true
  });

  console.log("====================Response====================");
  console.log(response.output_text);

  // Print tool invocation count
  console.log("====================Tool Invocation Count====================");
  if (response.usage && response.usage.x_tools) {
    console.log(`Web Extractor invocations: ${response.usage.x_tools.web_extractor?.count || 0}`);
    console.log(`Web Search invocations: ${response.usage.x_tools.web_search?.count || 0}`);
  }
  // Uncomment to view intermediate output
  // console.log(JSON.stringify(response.output[0], null, 2));
}

main();
```

curl

```bash {9}
curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "model": "qwen3.8-max",
  "input": "Please visit the official QwenCloud documentation, find the code interpreter topic and summarize it",
  "tools": [
    {"type": "web_search"},
    {"type": "web_extractor"}
  ],
  "enable_thinking": true
}'
```

Estrutura de resposta

A resposta contém o texto gerado pelo modelo e metadados sobre o uso de ferramentas.

Como funciona

1. Inclua web_extractor (e tipicamente web_search) na tools Uma série de pedidos de API, junto com um alerta que faz referência a um URL ou tópico.
2. O modelo determina quais páginas buscar, recupera seu conteúdo, e o adiciona ao contexto como tokens de entrada adicionais.
3. O modelo gera uma resposta baseada no conteúdo recuperado.

Conteúdos extraídos aumentam as entradas e afetam a faturação. Veja [Billing] (#billing) para detalhes.

Quando usar o extrator da web

Use web_extractor Quando você precisa do modelo para ler o conteúdo real de uma página - não apenas um resumo de busca-resultado.

Métodos de invocação

O extrator da web suporta quatro APIs. A API Responses fornece o maior controle sobre o comportamento da ferramenta. Use-a para novas integrações.

Quando se usa qwen3.7-max, set enable_thinking para true.

Responses API

```python
response = client.responses.create(
  model="qwen3.8-max",
  input="Summarize the content at https://example.com/article",
  tools=[
    {"type": "web_search"},
    {"type": "web_extractor"}
  ],
  extra_body={
    "enable_thinking": True
  }
)
```

Chat Completions API

```python
completion = client.chat.completions.create(
  model="qwen3.8-max",
  messages=[{"role": "user", "content": "Summarize the content at https://example.com/article"}],
  extra_body={
    "enable_thinking": True,
    "enable_search": True,
    "search_options": {"search_strategy": "agent_max"}
  },
  stream=True
)
```

DashScope API

```python
from dashscope import Generation

response = Generation.call(
  model="qwen3.8-max",
  messages=[{"role": "user", "content": "Summarize the content at https://example.com/article"}],
  enable_search=True,
  search_options={"search_strategy": "agent_max"},
  enable_thinking=True,
  result_format="message",
  stream=True,
  incremental_output=True
)
```

Anthropic-compatible

 Adicione a ferramenta de busca da web do lado do servidor Anthropic (`name` - Pronto para... `web_fetch`) para o `tools`  parâmetro para ativar o extrator web.  Você também deve adicionar a ferramenta de busca na web (`name` - Pronto para... `web_search`) no mesmo pedido. O ponto final é `https://maas.qwencloudapi.com/apps/anthropic`.

> Este método visa clientes oficiais antrópicos como Claude Code.  Nesses clientes, uma pergunta simples de linguagem natural desencadeia o extrator sem configuração extra.

>  Quando você ligar para a API diretamente com o SDK Antrópico ou mais HTTP, passe o identificador do cliente. `x-anthropic-billing-header: cc_entrypoint=cli;` Em `system`.  Caso contrário, o extrator da web não faz efeito.

>  Sobre a versão da ferramenta, o sufixo da data. `type` (por exemplo `web_fetch_20250910` e `web_search_20250305`) é determinado pela versão do cliente oficial Antrópico, e um cliente mais novo pode enviar uma versão diferente datada. QwenCloud  Identifica ambas as ferramentas por categoria e não valida o sufixo de data, então você não precisa afixar `type` para uma versão específica.  Basta passar o valor que seu cliente realmente envia.

> Se você adicionar a ferramenta de busca da web sem a ferramenta de busca da web, a solicitação falha com o `InvalidParameter`  Erro: `The web_extractor tool must be executed with web_search tool.`

```python
# Import dependencies and create the client...
message = client.messages.create(
    model="qwen3.8-max",
    max_tokens=4096,
    # Pass the client identifier
    system=[{"type": "text", "text": "x-anthropic-billing-header: cc_entrypoint=cli;"}],
    messages=[{"role": "user", "content": "Read the QwenCloud code interpreter documentation and summarize the key points."}],
    tools=[
        # Enabling the web extractor requires the web search tool as well
        # The date suffix in type depends on the client version. The values below are the ones current Claude Code sends.
        {"type": "web_search_20250305", "name": "web_search", "max_uses": 5},
        {"type": "web_fetch_20250910", "name": "web_fetch", "max_uses": 5}
    ]
)
```

O processo de extração é devolvido como `server_tool_use` (Pedir pedido) e `web_fetch_tool_result`  Blocos de conteúdo. O número de buscas é relatado em `usage.server_tool_use.web_fetch_requests`.

Transmita eventos de extração de rede

Para conceitos de streaming (protocolo SSE, como habilitar streaming e uso de fichas), veja Streaming output. Esta seção cobre apenas os tipos de eventos específicos para web extrator.

A extração da internet pode levar tempo. Use streaming para receber passos de raciocínio, chamadas de ferramentas e texto de resposta como eles acontecem. A API Responses expõe o status de execução intermediária para cada chamada de ferramenta, tornando-a a melhor escolha para streaming.

Ao transmitir com a API Responses, os seguintes tipos de eventos indicam progresso através do oleoduto de extração e geração:

Para lidar com o web_extractor_call Evento em um fluxo, verifique o tipo de evento e leia seu goal e output Campos:

for chunk in stream:
  if chunk.type == 'response.output_item.done':
    if hasattr(chunk, 'item') and chunk.item.type == 'web_extractor_call':
      print(f"Fetched: {chunk.item.goal}")
      print(f"Content: {chunk.item.output}")
  elif chunk.type == 'response.output_text.delta':
    print(chunk.delta, end='', flush=True)
  elif chunk.type == 'response.completed':
    usage = chunk.response.usage
    if hasattr(usage, 'x_tools') and usage.x_tools:
      print(f"Web Extractor invocations: {usage.x_tools.get('web_extractor', {}).get('count', 0)}")

Modelos apoiados.

Modelos recomendados

**Responde API **

• Qwen-Max: Qwen3.8-Max série, Qwen3.7-Max Série
• Qwen-Plus: Qwen3.7-Plus série, Qwen3.6-Plus série, Qwen3.5-Plus Série
• Qwen-Flash: qwen3.8-flash
• DeepSeek: deepseek-v4.1-flash, deepseek-v4-pro-0813, deepseek-v4-flash-0731, deepseek-v4-pro
• GLM: glm-5.2
• Qwen3.8 Série de código aberto

**Chat Completions API / DashScope

• Qwen-Max (Modo de pensamento): Qwen3.7-Max Série
• Qwen-Plus: Qwen3.5-Plus Série

Outros modelos

Os seguintes modelos também suportam esta ferramenta, mas podem não funcionar tão bem quanto os modelos recomendados. Só suportada através da API Responses.

• Qwen-Flash: qwen3.8-flash, Qwen3.7-Flash série, Qwen3.6-Flash série, Qwen3.5-Flash Série
• Qwen3.8 Série de código aberto (qwen3.8-2.4t-a95b)
• Qwen3.6 Série de código aberto (excluindo qwen3.6-27b)
• Qwen3.5 Série de código aberto
• DeepSeek: deepseek-v4.1-flash, deepseek-v4-pro-0813, deepseek-v4-flash-0731, deepseek-v4-pro
• GLM: glm-5.2

Limitações

• Extrator de rede recupera apenas páginas acessíveis ao público. Páginas por trás da autenticação ou paywalls retornam conteúdo vazio.
• Páginas muito grandes podem ser truncadas antes de serem adicionadas à janela de contexto.
• Conteúdo dinâmico, exclusivamente, produzido pelo JavaScript, pode não ser totalmente capturado.
• O conteúdo extraído conta como fichas de entrada, o que aumenta a latência e o custo para páginas grandes.

Erro ao lidar com isso.

Quando a extração falha, o modelo não levanta um erro. Em vez disso, o web_extractor_call O item na saída de resposta retorna conteúdo vazio ou parcial, e o modelo gera sua resposta com base em qualquer contexto disponível.

Cenários comuns de falha:

Para verificar se a extração foi bem sucedida, inspecione o web_extractor_call itens em response.output Ou verificar. usage.x_tools.web_extractor.count para o número de invocações bem sucedidas.

Contagem

Os custos do extrator de rede têm dois componentes:

Os preços listados abaixo são os preços de lista. Para promoções atuais e preços com desconto, visite o [Modelo Marketplace] (https://www.qwencloud.com/models).