Skip to main content
Visual understanding

Extração de texto (Qwen-OCR)

O Qwen-OCR é um modelo de compreensão visual que extrai texto e dados estruturados de imagens, como documentos digitalizados, tabelas, recibos, entre outros. Ele processa vários idiomas e suporta tarefas avançadas de OCR: extração de informações, análise de tabelas, reconhecimento de fórmulas e interpretação de documentos.

Experimente online: Acesse o console do Alibaba Cloud Model Studio, selecione a região no canto superior direito, acesse a página de visão e selecione Qwen OCR.

Exemplos

Imagem de entradaResultado do reconhecimento
Reconhecimento de múltiplos idiomasimageINTERNATIONALMOTHER LANGUAGEDAYПривет!你好!Bonjour!Merhaba!Ciao!Hello!Ola!בר מולדSalam!
Reconhecimento de imagens inclinadasimageProduct IntroductionImported fiber filaments from South Korea.6941990612023Item No.: 2023
Localização da posição do textoimg_1
A tarefa high-precision recognition oferece suporte à localização de texto.
Visualização da localizaçãoimg_1_location
Consulte FAQ para saber como desenhar a caixa delimitadora de cada linha de texto sobre a imagem original.

Seleção de modelo

O Qwen-OCR oferece os modelos listados abaixo. Escolha aquele que melhor atende aos requisitos do seu negócio:
  • Qwen3.5-OCR: Baseado na arquitetura Qwen3.5, com atualizações abrangentes em análise de documentos, localização de texto e extração de informações-chave. Oferece suporte a conversas de múltiplas turnos e análise de documentos PDF. Apresenta melhorias significativas na extração de dados de certificados oficiais (como carteiras de identidade e habilitação). Para verificar os tipos de certificados suportados, consulte Supported certificate and document types. Inclui o modelo qwen3.5-ocr.
  • Qwen-VL-OCR: Desenvolvido sobre a arquitetura Qwen3-VL. Suporta tarefas integradas como análise de documentos, localização de texto (reconhecimento de alta precisão), extração de informações, análise de tabelas, reconhecimento de fórmulas, reconhecimento geral de texto e suporte multilíngue. Também corrige automaticamente a rotação de imagens. Abrange os modelos qwen-vl-ocr (estável), qwen-vl-ocr-latest (mais recente), qwen-vl-ocr-2025-11-20 e qwen-vl-ocr-2025-08-28.
  • Versões anteriores (não recomendadas): Estas versões são inferiores aos modelos mais recentes tanto em recursos quanto em desempenho. Recomendamos a migração para o qwen3.5-ocr. Esta categoria inclui os modelos qwen-vl-ocr-2025-04-13 e qwen-vl-ocr-2024-10-28.
Nos modelos qwen-vl-ocr, qwen-vl-ocr-2025-04-13 e qwen-vl-ocr-2025-08-28, o parâmetro max_tokens (comprimento máximo de saída) tem como padrão 4096. Para aumentar esse valor para uma faixa entre 4097 e 8192, entre em contato com seu gerente comercial e forneça as seguintes informações: ID da sua conta Alibaba Cloud, tipo de imagem (como documentos, e-commerce ou contratos), nome do modelo, estimativa de Consultas Por Segundo (QPS) e total diário de requisições, além da porcentagem de requisições em que a saída do modelo excede 4096 tokens.
Experiência online: Visite o console do Model Studio, selecione a região desejada no canto superior direito e acesse a seção Vision Models para testar os modelos Qwen-OCR.

Preparativos

  • Create an API key e set it as an environment variable.
  • Caso utilize o OpenAI SDK ou DashScope SDK, siga as instruções em install the latest SDK version. Versões mínimas exigidas: DashScope Python SDK 1.22.2, Java SDK 2.21.8.
    • DashScope SDK
      • Vantagens: Acesso completo a recursos avançados — correção de rotação de imagem e tarefas nativas de OCR — por meio de uma API simples.
      • Mais indicado para: Projetos que necessitam do conjunto completo de funcionalidades.
    • SDK compatível com OpenAI
      • Vantagens: Substituição direta para integrações existentes baseadas no OpenAI SDK.
      • Limitações: Recursos avançados, como correção de rotação e tarefas integradas de OCR, não estão expostos diretamente como parâmetros. É necessário simulá-los através da elaboração cuidadosa de prompts e da análise da saída gerada.
      • Recomendado quando: O projeto já utiliza OpenAI e não depende de funcionalidades exclusivas do DashScope.

Primeiros passos

O exemplo a seguir extrai campos estruturados de uma imagem de bilhete de trem (URL) e retorna os resultados em formato JSON. Para arquivos locais, consulte how to pass a local file. Para restrições de entrada, consulte image limitations.
  • OpenAI compatible-Chat
  • OpenAI compatible-Response
  • DashScope
Python
from openai import OpenAI
import os

PROMPT_TICKET_EXTRACTION = """
Please extract the invoice number, train number, departure station, destination station, departure date and time, seat number, seat type, ticket price, ID card number, and passenger name from the train ticket image.
Extract the key information accurately. Do not omit information or fabricate false information. Replace any single character that is blurry or obscured by glare with a question mark (?).
Return the data in JSON format: {'Invoice Number': 'xxx', 'Train Number': 'xxx', 'Departure Station': 'xxx', 'Destination Station': 'xxx', 'Departure Date and Time': 'xxx', 'Seat Number': 'xxx', 'Seat Type': 'xxx', 'Ticket Price': 'xxx', 'ID Card Number': 'xxx', 'Passenger Name': 'xxx'}
"""

try:
    client = OpenAI(
        # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
        # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )
    completion = client.chat.completions.create(
        model="qwen-vl-ocr-2025-11-20",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {"url":"https://img.alicdn.com/imgextra/i2/O1CN01ktT8451iQutqReELT_!!6000000004408-0-tps-689-487.jpg"},
                        # The minimum pixel threshold for the input image. If the image is smaller than this value, it is scaled up until the total pixels exceed min_pixels.
                        "min_pixels": 32 * 32 * 3,
                        # The maximum pixel threshold for the input image. If the image is larger than this value, it is scaled down until the total pixels are below max_pixels.
                        "max_pixels": 32 * 32 * 8192
                    },
                    # The model supports passing a prompt in the text field. If no prompt is passed, the default prompt is used: Please output only the text content from the image without any additional descriptions or formatting.
                    {"type": "text",
                     "text": PROMPT_TICKET_EXTRACTION}
                ]
            }
        ])
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"Error message: {e}")

{
  "choices": [{
    "message": {
      "content": "```json\n{\n    \"Invoice Number\": \"24329116804000\",\n    \"Train Number\": \"G1948\",\n    \"Departure Station\": \"Nanjing South Station\",\n    \"Destination Station\": \"Zhengzhou East Station\",\n    \"Departure Date and Time\": \"2024-11-14 11:46\",\n    \"Seat Number\": \"Car 04, Seat 12A\",\n    \"Seat Type\": \"Second Class\",\n    \"Ticket Price\": \"￥337.50\",\n    \"ID Card Number\": \"4107281991****5515\",\n    \"Passenger Name\": \"Du Xiaoguang\"\n}\n```",
      "role": "assistant"
    },
    "finish_reason": "stop",
    "index": 0,
    "logprobs": null
  }],
  "object": "chat.completion",
  "usage": {
    "prompt_tokens": 606,
    "completion_tokens": 159,
    "total_tokens": 765
  },
  "created": 1742528311,
  "system_fingerprint": null,
  "model": "qwen-vl-ocr-latest",
  "id": "chatcmpl-20e5d9ed-e8a3-947d-bebb-c47ef1378598"
}

Chamar tarefas integradas

Os modelos (exceto qwen-vl-ocr-2024-10-28) incluem tarefas integradas para cenários comuns de OCR. Como chamar uma tarefa integrada:
  • DashScope SDK: Defina o parâmetro ocr_options para invocar as tarefas integradas. A partir do modelo qwen3.5-ocr, essas tarefas funcionam em conjunto com seu Prompt personalizado (deixando de substituí-lo), e os resultados são retornados no campo ocr_result. Modelos anteriores utilizam um Prompt interno fixo.
  • OpenAI-compatible SDK: Passe manualmente o Prompt específico da tarefa na sua mensagem.
Cada tarefa possui um valor de task, um Prompt fixo, um formato de saída e um exemplo de saída:
  • Reconhecimento de alta precisão
  • Extração de informações
  • Análise de tabelas
  • Análise de documentos
  • Reconhecimento de fórmulas
  • Reconhecimento geral de texto
  • Reconhecimento multilíngue
Para reconhecimento de alta precisão, utilize versões do modelo posteriores a qwen-vl-ocr-2025-08-28 ou a versão mais recente (recomendado). Recursos:
  • Reconhece e extrai conteúdo textual.
  • Detecta a posição do texto ao localizar linhas de texto e retornar suas coordenadas.
Para desenhar caixas delimitadoras na imagem original usando as coordenadas retornadas, consulte o FAQ .
Valor de taskPrompt especificadoFormato de saída e exemplo
advanced_recognitionLocaliza todas as linhas de texto e retorna as coordenadas do retângulo rotacionado ([cx, cy, width, height, angle]).
  • Formato: Texto simples ou um objeto JSON obtido diretamente do campo ocr_result.
  • Exemplo:

{
  "output": {
    "choices": [
      {
        "message": {
          "content": [
            {
              "ocr_result": {
                "words_info": [
                  {
                    "location": [331, 139, 465, 139, 465, 166, 331, 166],
                    "rotate_rect": [398,153,134,27,90],
                    "text": "Magsafe"
                  },
                  {
                    "location": [411, 86, 411, 220, 384, 220, 384, 86],
                    "rotate_rect": [680,250,40,167,90],
                    "text": "金盾系列"
                  },
  • text: O conteúdo textual de cada linha.
  • location:
    • Valor de exemplo: [x1, y1, x2, y2, x3, y3, x4, y4]
    • Significado: As coordenadas absolutas dos quatro vértices da caixa de texto. O canto superior esquerdo da imagem original é a origem (0,0). A ordem dos vértices é fixa: superior esquerdo → superior direito → inferior direito → inferior esquerdo.
  • rotate_rect:
    • Valor de exemplo: [center_x, center_y, width, height, angle]
    • Significado: Outra representação da caixa de texto, onde center_x e center_y são as coordenadas do centroide da caixa de texto, width é a largura, height é a altura e angle é o ângulo de rotação da caixa de texto em relação à direção horizontal. O valor está no intervalo de [-90, 90].
import os
import dashscope

# Replace {WorkspaceId} with your workspace ID. URLs vary by region.
# If you use a model in the China (Beijing) region, change the base_url to https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

messages = [{
            "role": "user",
            "content": [{
                "image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/ctdzex/biaozhun.jpg",
                # The minimum pixel threshold for the input image. If the image is smaller than this value, it is scaled up until the total pixels are greater than min_pixels.
                "min_pixels": 32 * 32 * 3,
                # The maximum pixel threshold for the input image. If the image is larger than this value, it is scaled down until the total pixels are less than max_pixels.
                "max_pixels": 32 * 32 * 8192,
                # Specifies whether to enable automatic image rotation.
                "enable_rotate": False}]
            }]

response = dashscope.MultiModalConversation.call(
    # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen-vl-ocr-2025-11-20',
    messages=messages,
    # Set the built-in task to high-precision recognition.
    ocr_options={"task": "advanced_recognition"}
)
# The high-precision recognition task returns the result as plain text.
print(response["output"]["choices"][0]["message"].content[0]["text"])

{
  "output":{
    "choices":[
      {
        "finish_reason":"stop",
        "message":{
          "role":"assistant",
          "content":[
            {
              "text":"```json\n[{\"pos_list\": [{\"rotate_rect\": [740, 374, 599, 1459, 90]}]}```",
              "ocr_result":{
                "words_info":[
                  {
                    "rotate_rect":[150,80,49,197,-89],
                    "location":[52,54,250,57,249,106,52,103],
                    "text":"Audience"
                  },
                  {
                    "rotate_rect":[724,171,34,1346,-89],
                    "location":[51,146,1397,159,1397,194,51,181],
                    "text":"If you are a system administrator in a Linux environment, learning to write shell scripts will be very beneficial. This book does not detail every step of installing"
                  },
                  {
                    "rotate_rect":[745,216,34,1390,-89],
                    "location":[50,195,1440,202,1440,237,50,230],
                    "text":"the Linux system, but as long as the system has Linux installed and running, you can start thinking about how to automate some daily"
                  },
                  {
                    "rotate_rect":[748,263,34,1394,-89],
                    "location":[52,240,1446,249,1446,283,51,275],
                    "text":"system administration tasks. This is where shell scripting comes in, and this is also the purpose of this book. This book will"
                  },
                  {
                    "rotate_rect":[749,308,34,1395,-89],
                    "location":[51,285,1446,296,1446,331,51,319],
                    "text":"demonstrate how to use shell scripts to automate system administration tasks, from monitoring system statistics and data files to for your boss"
                  },
                  {
                    "rotate_rect":[123,354,33,146,-89],
                    "location":[50,337,197,338,197,372,50,370],
                    "text":"generating reports."
                  },
                  {
                    "rotate_rect":[751,432,34,1402,-89],
                    "location":[51,407,1453,420,1453,454,51,441],
                    "text":"If you are a home Linux enthusiast, you can also benefit from this book. Nowadays, users can easily get lost in a graphical environment built from many stacked components."
                  },
                  {
                    "rotate_rect":[755,477,31,1404,-89],
                    "location":[54,458,1458,463,1458,495,54,490],
                    "text":"Most desktop Linux distributions try to hide the internal details of the system from general users. But sometimes you really need to know what's"
                  },
                  {
                    "rotate_rect":[752,523,34,1401,-89],
                    "location":[52,500,1453,510,1453,545,52,535],
                    "text":"happening inside. This book will show you how to start the Linux command line and what to do next. Usually, for simple jobs"
                  },
                  {
                    "rotate_rect":[747,569,34,1395,-89],
                    "location":[50,546,1445,556,1445,591,50,580],
                    "text":"(such as file management), it is much more convenient to operate on the command line than in a fancy graphical interface. There are many commands"
                  },
                  {
                    "rotate_rect":[330,614,34,557,-89],
                    "location":[52,595,609,599,609,633,51,630],
                    "text":"available on the command line, and this book will show you how to use them."
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  },
  "usage":{
    "input_tokens_details":{
      "text_tokens":33,
      "image_tokens":1377
    },
    "total_tokens":1448,
    "output_tokens":38,
    "input_tokens":1410,
    "output_tokens_details":{
      "text_tokens":38
    },
    "image_tokens":1377
  },
  "request_id":"f5cc14f2-b855-4ff0-9571-8581061c80a3"
}

Análise de documentos PDF

O qwen3.5-ocr permite enviar arquivos PDF diretamente pela Response API para análise de documentos, sem necessidade de dividir manualmente o PDF em imagens. O tamanho da saída não é limitado pelo comprimento máximo de saída do modelo, o que possibilita a análise completa de documentos longos. Apenas a Response API é suportada; a Chat API não é compatível. Limites para arquivos PDF: no máximo 100 MB. O limite de páginas depende de task em ocr_options: até 50 páginas quando task é definido como document_parsing e até 10 páginas quando task não é definido ou é definido como outra tarefa. Os exemplos a seguir utilizam a Response API para enviar arquivos PDF destinados à análise de documentos.
Python
import os
from openai import OpenAI

client = OpenAI(
    # If you have not configured an environment variable, replace the following line with your API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The URL below is for the China (Beijing) region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.5-ocr",
    input=[{
        "role": "user",
        "content": [{
            "type": "input_file",
            "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf"
        }]
    }],
    extra_body={
        "ocr_options": {"task": "document_parsing"}
    }
)

# Get the built-in task result
print(response.output[0].content[0].ocr_result)
Para modelos anteriores ( qwen-vl-ocr-2025-11-20 e anteriores) que não suportam a Response API, utilize uma biblioteca de processamento de imagens, como a Python com pdf2image , para converter cada página do PDF em uma imagem e, em seguida, aplique o método multi-image input para reconhecimento página por página.
Para mais casos de uso da OpenAI Responses API (como recuperar e gerenciar respostas concluídas do modelo), consulte OpenAI compatible - Responses .

Enviar um arquivo local (codificação Base64 ou caminho do arquivo)

Faça upload de arquivos locais usando codificação Base64 ou um caminho direto de arquivo. Selecione o método com base no tamanho do arquivo e no tipo de SDK — consulte How to select a file upload method. Ambos os métodos devem atender aos requisitos de arquivo descritos em Image limits.
  • Usar codificação Base64
  • Usar caminho do arquivo
Converta o arquivo para uma string codificada em Base64 e envie-a ao modelo. Este método é adequado para os SDKs OpenAI e DashScope, além de requisições HTTP.
  1. Codifique o arquivo: converta a imagem local em uma string codificada em Base64. 
    # Encoding function: Converts a local file to a Base64-encoded string.
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Replace xxx/eagle.png with the absolute path of your local image.
base64_image = encode_image("xxx/eagle.png")
  2. Construa uma Data URL no seguinte formato: data:[MIME_type];base64,{base64_image}.
    1. Substitua MIME_type pelo tipo de mídia real. Certifique-se de que o tipo corresponda ao valor MIME Type na tabela Image limits, como image/jpeg ou image/png.
    2. base64_image corresponde à string codificada em Base64 gerada na etapa anterior.
  3. Chame o modelo: passe a Data URL usando o parâmetro image ou image_url para chamar o modelo.
  • Enviar um caminho de arquivo
  • Enviar uma string codificada em Base64
O envio de caminho de arquivo é suportado apenas para chamadas feitas com os SDKs DashScope Python e Java. Este método não é compatível com DashScope HTTP ou métodos compatíveis com OpenAI.
Python
import os
import dashscope

# Replace {WorkspaceId} with your workspace ID. URLs vary by region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# Replace xxx/test.jpg with the absolute path of your local image.
local_path = "xxx/test.jpg"
image_path = f"file://{local_path}"
messages = [
    {
        "role": "user",
        "content": [
            {
                "image": image_path,
                # The minimum pixel threshold for the input image. If the image has fewer pixels than this value, the image is scaled up until the total number of pixels is greater than min_pixels.
                "min_pixels": 32 * 32 * 3,
                # The maximum pixel threshold for the input image. If the image has more pixels than this value, the image is scaled down until the total number of pixels is less than max_pixels.
                "max_pixels": 32 * 32 * 8192,
            },
            # If no built-in task is set for the model, you can pass a prompt in the text field. If you do not pass a prompt, the default prompt is used: Please output only the text content from the image without any additional descriptions or formatting.
            {
                "text": "Extract the invoice number, train number, departure station, destination station, departure date and time, seat number, seat type, ticket price, ID card number, and passenger name from the train ticket image. Extract the key information accurately. Do not omit or fabricate information. Replace any single character that is blurry or obscured by glare with a question mark (?). Return the data in JSON format: {'invoice_number': 'xxx', 'train_number': 'xxx', 'departure_station': 'xxx', 'destination_station': 'xxx', 'departure_date_and_time': 'xxx', 'seat_number': 'xxx', 'seat_type': 'xxx', 'ticket_price': 'xxx', 'id_card_number': 'xxx', 'passenger_name': 'xxx'}"
            },
        ],
    }
]

response = dashscope.MultiModalConversation.call(
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key.
    # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen-vl-ocr-2025-11-20",
    messages=messages,
)
print(response["output"]["choices"][0]["message"].content[0]["text"])

Outros casos de uso

Limitações

Limites de imagem

  • Dimensões e proporção: A largura e a altura da imagem devem ser superiores a 10 pixels. A proporção não pode exceder 200:1 ou 1:200.
  • Total de pixels: O modelo ajusta automaticamente a escala das imagens, portanto não há um limite rígido para o número total de pixels. No entanto, uma imagem não pode ultrapassar 15,68 milhões de pixels.
  • Formatos de imagem suportados
    • Para imagens com resolução abaixo de 4K (3840x2160), os seguintes formatos são suportados:

      Formato de imagem

      Extensões comuns

      Tipo MIME

      BMP

      .bmp

      image/bmp

      JPEG

      .jpe, .jpeg, .jpg

      image/jpeg

      PNG

      .png

      image/png

      TIFF

      .tif, .tiff

      image/tiff

      WEBP

      .webp

      image/webp

      HEIC

      .heic

      image/heic

    • Para imagens com resolução entre 4K(3840x2160) e 8K(7680x4320), apenas os formatos JPEG, JPG e PNG são suportados.
  • Tamanho da imagem:
    • Ao fornecer uma imagem por meio de uma URL pública ou caminho local: qwen3.5-ocr aceita imagens de até 20 MB; outras versões suportam até 10 MB.
    • Se você fornecer os dados em codificação Base64, a string codificada não pode exceder 10 MB.
    Consulte também: How do I compress an image or video to the required size? .

Limites do modelo

  • System message: O Qwen-OCR utiliza uma System Message interna fixa e não aceita mensagens personalizadas. Passe todas as instruções na User Message.
  • Conversas de múltiplas rodadas: A partir da versão qwen3.5-ocr, conversas de múltiplas rodadas são suportadas — você pode enviar mensagens de texto subsequentes sem uma URL de imagem. As versões qwen-vl-ocr-2025-11-20 e anteriores processam apenas a mensagem mais recente e não retêm contexto.
  • Risco de alucinação: O modelo pode apresentar alucinações se o texto em uma imagem for muito pequeno ou tiver baixa resolução. Além disso, a precisão das respostas para perguntas não relacionadas à extração de texto não é garantida.
  • Erro ao processar arquivos de texto:
    • Para arquivos que contêm dados de imagem, siga as recomendações em Going live para transformá-los em uma sequência de imagens antes do processamento.
    • Para arquivos com texto simples ou dados estruturados, utilize Qwen-Long, um modelo capaz de analisar textos longos.

Tipos de certificados e documentos suportados

A tarefa de extração de informações suporta a extração de dados estruturados dos seguintes certificados, recibos e licenças.
  • Passaportes e documentos de viagem: Passaporte chinês, passaporte de Macau, Permissão de Viagem para Residentes de Hong Kong e Macau no Continente, Permissão de Viagem para Residentes de Taiwan no Continente e Permissão de Retorno para Residentes de Hong Kong e Macau.
  • Documentos veiculares e notas fiscais de venda: Carteira de motorista, placa do veículo, certificado de conformidade do veículo, certificado de registro do veículo, nota fiscal de venda de veículo automotor e nota fiscal de venda de veículo usado.
  • Notas fiscais e recibos tributários: Nota fiscal comum de IVA (rolo), nota fiscal especial de valor fixo, nota fiscal impressa por máquina geral, certificado de pagamento de impostos e recibo de receita não tributária central.
  • Recibos de transporte: Bilhete de trem de alta velocidade 12306, bilhete de trem, bilhete de barco, recibo de pedágio de via expressa e nota fiscal impressa por máquina de via expressa.
  • Cartões financeiros e recibos: Cartão de crédito, letra de câmbio bancária eletrônica, recibo de pagamento e cartão de seguridade social.
  • Licenças comerciais e alvarás: Licença comercial, licença de operação de alimentos, licença de produção de alimentos, licença de operação farmacêutica e licença de operação de dispositivos médicos.
  • Certificado imobiliário: Certificado de propriedade imobiliária.
  • Carteiras de identidade internacionais: Identidade de Hong Kong, identidade de Macau, identidade indonésia, identidade tailandesa, identidade vietnamita, identidade malaia, identidade filipina, identidade indiana, identidade turca, identidade paquistanesa, identidade mexicana, identidade do Reino Unido e identidade dos EUA.
  • Passaportes e carteiras de motorista internacionais: Passaporte indiano, passaporte de Singapore, passaporte tailandês, passaporte dos EUA, passaporte australiano, passaporte dos Emirados Árabes Unidos, carteira de motorista filipina, carteira de motorista japonesa e carteira de motorista dos EUA.

Faturamento e limitação de taxa

  • Faturamento: O Qwen-OCR é um modelo multimodal. O custo total é calculado da seguinte forma: (Número de tokens de entrada × Preço unitário de entrada) + (Número de tokens de saída × Preço unitário de saída). Visualize as faturas ou recarregue sua conta no console Expenses and Costs.
    • Cálculo de tokens de imagem: Utilize o código abaixo para estimar o uso de tokens de imagem. O faturamento real baseia-se na resposta da API.
      Fórmula: Tokens de imagem = (h_bar * w_bar) / token_pixels + 2.
      • h_bar * w_bar representa as dimensões da imagem redimensionada. O modelo pré-processa a imagem ajustando sua escala para um limite específico de pixels. Esse limite depende do valor do parâmetro max_pixels.
      • token_pixels representa o valor de pixels por Token.
        • Para qwen3.5-ocr, qwen-vl-ocr, qwen-vl-ocr-2025-11-20 e qwen-vl-ocr-latest, este valor é fixo em 32*32 (ou seja, 1024).
        • Para outros modelos, este valor é fixo em 28*28 (ou seja, 784).
      Este código demonstra a lógica aproximada de redimensionamento de imagem utilizada pelo modelo. Use-o para estimar a contagem de tokens de uma imagem. O faturamento real baseia-se na resposta da API.
      import math
from PIL import Image

def smart_resize(image_path, min_pixels, max_pixels):
    """
    Pre-process an image.

    Parameters:
        image_path: The path to the image.
    """
    # Open the specified PNG image file.
    image = Image.open(image_path)

    # Get the original dimensions of the image.
    height = image.height
    width = image.width
    # Adjust the height to be a multiple of 28 or 32.
    h_bar = round(height / 32) * 32
    # Adjust the width to be a multiple of 28 or 32.
    w_bar = round(width / 32) * 32

    # Scale the image to adjust the total number of pixels to be within the range [min_pixels, max_pixels].
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = math.floor(height / beta / 32) * 32
        w_bar = math.floor(width / beta / 32) * 32
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = math.ceil(height * beta / 32) * 32
        w_bar = math.ceil(width * beta / 32) * 32
    return h_bar, w_bar

# Replace xxx/test.png with the path to your local image.
h_bar, w_bar = smart_resize("xxx/test.png", min_pixels=32 * 32 * 3, max_pixels=8192 * 32 * 32)
print(f"The scaled image dimensions are: height {h_bar}, width {w_bar}")

# Calculate the number of image tokens: total pixels divided by 32 * 32.
token = int((h_bar * w_bar) / (32 * 32))

# <|vision_bos|> and <|vision_eos|> are visual markers. Each is counted as 1 token.
print(f"Total number of image tokens: {token + 2}")
  • Limitação de taxa: Para consultar os limites de taxa do Qwen-OCR, veja Rate limiting.
  • Cota gratuita (apenas Singapore): O Qwen-OCR oferece uma cota gratuita de 1 milhão de tokens. Essa cota é válida por 90 dias, contados a partir da data de ativação do Model Studio ou da aprovação da sua solicitação para usar o modelo.

Entrada em produção

  • Pré-processamento de imagens:
    • Garanta que as imagens de entrada estejam nítidas, com iluminação uniforme e sem compressão excessiva:
      • Armazene e transmita imagens em formato sem perdas (como PNG) para evitar perda de informações.
      • Para melhorar a definição da imagem, utilize algoritmos de redução de ruído, como filtragem média ou mediana, para suavizar imagens ruidosas.
      • Para corrigir iluminação irregular, aplique algoritmos como equalização adaptativa de histograma e ajuste o brilho e o contraste.
    • Imagens inclinadas: Defina enable_rotate: true no DashScope SDK para corrigir a rotação antes do reconhecimento.
    • Imagens muito pequenas ou muito grandes: Use min_pixels e max_pixels para controlar o dimensionamento da imagem.
      • min_pixels: Amplia imagens pequenas para melhorar os detalhes. Mantenha o valor padrão.
      • max_pixels: Evita que imagens excessivamente grandes consumam tokens demais. O padrão atende à maioria dos casos. Aumente esse valor quando textos pequenos não forem detectados — isso eleva o consumo de tokens.
  • Validação de resultados: Os resultados de reconhecimento do modelo podem conter erros. Em operações comerciais críticas, implemente um processo de revisão manual ou adicione regras de validação para verificar a precisão da saída do modelo. Por exemplo, use validação de formato para números de carteira de identidade e cartões bancários.
  • Processamento em lote: Para cargas de trabalho de alto volume e não em tempo real, utilize the Batch API para processar tarefas de forma assíncrona com custo reduzido.

Perguntas frequentes

Escolha o melhor método de upload com base no tipo de SDK, no tamanho do arquivo e na estabilidade da rede.

Tipo

Especificações

DashScope SDK (Python, Java)

Compatível com OpenAI / DashScope HTTP

Imagem

Maior que 7 MB e menor que 10 MB

Informe o caminho local

Apenas URLs públicas são suportadas. Utilize o Object Storage Service.

Menor que 7 MB

Informe o caminho local

Codificação Base64

A codificação Base64 aumenta o tamanho dos dados. O arquivo original deve ter menos de 7 MB.
O uso de caminho local ou codificação Base64 ajuda a prevenir timeouts de download no servidor e melhora a estabilidade.
Depois que o modelo Qwen-OCR retornar os resultados de localização de texto, utilize o código no arquivo draw_bbox.py para desenhar os quadros de detecção e seus rótulos na imagem original.
Ao usar qwen3.5-ocr, se o seu Prompt personalizado contiver uma estrutura HTML completa, como <html><body>...</body></html>, o modelo pode seguir essa estrutura e retornar o resultado do OCR em formato HTML em vez de texto simples. Assim, a resposta parece vazia ou aparenta conter tags de frontend. Uma tag simples, como um único <br>, não aciona esse comportamento.Para resolver esse problema, utilize um dos métodos abaixo:
  • Verifique se o seu Prompt contém uma estrutura completa de tags HTML. Caso positivo, substitua-a por uma instrução em texto simples e tente novamente. Por exemplo, altere <html><body>Extract all text from the image</body></html> para Extract all text from the image.
  • Se não tiver certeza se o seu Prompt afeta o formato de saída, omita o campo text para utilizar o Prompt padrão do modelo.
  • Utilize o modelo qwen3.7-plus. Este modelo retorna um resultado em texto simples mesmo quando você passa o mesmo Prompt contendo uma estrutura HTML.

Referência da API

Para consultar os parâmetros de entrada e saída do Qwen-OCR, consulte Qwen-OCR API reference.

Códigos de erro

Se a chamada ao modelo falhar e retornar uma mensagem de erro, consulte Error codes para obter a solução.
Começar
Faturamento
Plano de Tokens
Playground de Modelos
Clientes e Ferramentas de Desenvolvedor
Inferência do Modelo
Ajuste fino
Implantação
Avaliação
Compressão de Modelos
Estatísticas e Monitoramento
Segurança e Conformidade
Melhores Práticas
Suporte
Registro de alterações