Skip to main content

Extracción de texto (Qwen-OCR)

Qwen-OCR es un modelo de comprensión visual que extrae texto y datos estructurados de imágenes: documentos escaneados, tablas, recibos y más. Maneja múltiples idiomas y admite tareas avanzadas de OCR: extracción de información, análisis de tablas, reconocimiento de fórmulas y análisis de documentos.

Pruébelo en línea: Vaya a la consola de Alibaba Cloud Model Studio, seleccione la región en la esquina superior derecha, vaya a la página de visión y seleccione Qwen OCR.

Ejemplos

Imagen de entradaResultado del reconocimiento
Reconocimiento de múltiples idiomasimagenINTERNATIONALMOTHER LANGUAGEDAYПривет!你好!Bonjour!Merhaba!Ciao!Hello!Ola!בר מולדSalam!
Reconocer imágenes inclinadasimagenIntroducción del productoFilamentos de fibra importados de Corea del Sur.6941990612023N.º de artículo: 2023
Localizar posición del textoimg_1
La tarea de reconocimiento de alta precisión admite la localización de texto.
Visualización de la localizaciónimg_1_location
Consulte las Preguntas frecuentes sobre cómo dibujar el cuadro delimitador de cada línea de texto en la imagen original.

Selección de modelo

Qwen-OCR proporciona los siguientes modelos. Elija según sus requisitos empresariales:
  • Qwen3.5-OCR: Construido sobre la arquitectura Qwen3.5, con mejoras integrales en el análisis de documentos, la localización de texto y la extracción de información clave. Admite conversaciones de múltiples turnos y análisis de documentos PDF. Mejora significativamente la extracción de información de certificados comerciales (como tarjetas de identificación y licencias de conducir). Para consultar los tipos de certificados admitidos, vea Tipos de certificados y documentos admitidos. Incluye el modelo qwen3.5-ocr.
  • Qwen-VL-OCR: Construido sobre la arquitectura Qwen3-VL. Admite tareas integradas que incluyen análisis de documentos, localización de texto (reconocimiento de alta precisión), extracción de información, análisis de tablas, reconocimiento de fórmulas, reconocimiento general de texto y reconocimiento multilingüe. También admite corrección de rotación de imágenes. Incluye los modelos qwen-vl-ocr (estable) (más reciente) y qwen-vl-ocr-2025-11-20.
  • Versiones anteriores (no recomendadas): Estas versiones son inferiores a los modelos más nuevos tanto en funciones como en rendimiento. Recomendamos migrar a qwen3.5-ocr. Incluye modelos qwen-vl-ocr-2024-10-28.
En los modelos qwen-vl-ocr, models, the , el parámetro max_tokens (longitud máxima de salida) tiene un valor predeterminado de 4096. Para aumentar este valor a un rango de 4097 a 8192, póngase en contacto con su gerente comercial y proporcione la siguiente información: su ID de cuenta de Alibaba Cloud, tipo de imagen (como imágenes de documentos, imágenes de comercio electrónico o contratos), nombre del modelo, consultas por segundo (QPS) estimadas y solicitudes diarias totales, y el porcentaje de solicitudes donde la longitud de salida del modelo excede los 4096 tokens.
Experiencia en línea: Visite la consola de Model Studio, seleccione la región objetivo en la esquina superior derecha y vaya a Modelos de visión para probar los modelos Qwen-OCR.

Preparativos

  • Crear una clave API y configurarla como variable de entorno.
  • Si utiliza el SDK de OpenAI o el SDK de DashScope, instale la última versión del SDK. Versiones mínimas: SDK de Python de DashScope 1.22.2, SDK de Java 2.21.8.
    • SDK de DashScope
      • Ventajas: Acceso completo a funciones avanzadas — corrección de rotación de imagen, tareas OCR integradas — con una API simple.
      • Ideal para: Proyectos que necesitan el conjunto completo de funciones.
    • SDK compatible con OpenAI
      • Ventajas: Reemplazo directo para integraciones existentes del SDK de OpenAI.
      • Limitaciones: Las funciones avanzadas, como la corrección de rotación de imagen y las tareas OCR integradas, no se exponen directamente como parámetros. Simúlelas elaborando prompts y analizando la salida.
      • Ideal para: Proyectos que ya utilizan OpenAI y no necesitan funciones exclusivas de DashScope.

Introducción

El siguiente ejemplo extrae campos estructurados de una imagen de boleto de tren (URL) y devuelve los resultados como JSON. Para archivos locales, consulte cómo pasar un archivo local. Para restricciones de entrada, consulte limitaciones de imagen.
  • Compatible con OpenAI-Chat
  • Compatible con OpenAI-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/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",
  "id": "chatcmpl-20e5d9ed-e8a3-947d-bebb-c47ef1378598"
}

Llamada a tareas integradas

Los modelos (excepto qwen-vl-ocr-2024-10-28) incluyen tareas integradas para escenarios comunes de OCR. Cómo llamar a una tarea integrada:
  • DashScope SDK: Configure el parámetro ocr_options para llamar a tareas integradas. A partir de qwen3.5-ocr, las tareas integradas funcionan junto con su Prompt personalizado (ya no lo sobrescriben), y los resultados de las tareas integradas se devuelven en el campo ocr_result. Los modelos anteriores utilizan un Prompt interno fijo.
  • SDK compatible con OpenAI: Pase el Prompt específico de la tarea manualmente en su mensaje.
Cada tarea tiene un valor task, un Prompt fijo, un formato de salida y un ejemplo de salida:
  • Reconocimiento de alta precisión
  • Extracción de información
  • Análisis de tablas
  • Análisis de documentos
  • Reconocimiento de fórmulas
  • Reconocimiento general de texto
  • Reconocimiento multilingüe
Para reconocimiento de alta precisión, utilice versiones del modelo posteriores a qwen-vl-ocr-2025-11-20 o la versión más reciente (recomendado). Características:
  • Reconoce y extrae contenido de texto.
  • Detecta la posición del texto localizando líneas de texto y generando sus coordenadas.
Para dibujar cuadros delimitadores en la imagen original utilizando las coordenadas devueltas, consulte las Preguntas frecuentes .
Valor de taskPrompt especificadoFormato de salida y ejemplo
advanced_recognitionLocalice todas las líneas de texto y devuelva las coordenadas del rectángulo rotado ([cx, cy, width, height, angle]).
  • Formato: Texto sin formato u objeto JSON que puede obtener directamente del campo ocr_result.
  • Ejemplo:
{
  "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: El contenido de texto de cada línea.
  • location:
    • Valor de ejemplo: [x1, y1, x2, y2, x3, y3, x4, y4]
    • Significado: Las coordenadas absolutas de los cuatro vértices del cuadro de texto. La esquina superior izquierda de la imagen original es el origen (0,0). El orden de los vértices es fijo: superior izquierdo → superior derecho → inferior derecho → inferior izquierdo.
  • rotate_rect:
    • Valor de ejemplo: [center_x, center_y, width, height, angle]
    • Significado: Otra representación del cuadro de texto, donde center_x and center_y are the coordinates of the text box centroid, width es el ancho, height es la altura y angle es el ángulo de rotación del cuadro de texto respecto a la dirección horizontal. El valor se encuentra en el rango 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álisis de documentos PDF

qwen3.5-ocr admite pasar archivos PDF directamente a través de la Response API para el análisis de documentos, sin necesidad de dividir manualmente el PDF en imágenes. La longitud de salida no está limitada por la longitud máxima de salida del modelo, lo que permite el análisis completo de documentos largos. Solo se admite la Response API; la Chat API no es compatible. Límites de archivos PDF: no más de 100 MB. El límite de páginas depende de task en ocr_options: hasta 50 páginas cuando task se establece en document_parsing, y hasta 10 páginas cuando task no se establece o se configura en otra tarea. Los siguientes ejemplos utilizan la API Response para pasar archivos PDF para el análisis 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 y previos) que no admiten la Response API, utilice una biblioteca de procesamiento de imágenes como pdf2image de Python para convertir cada página del PDF en una imagen y, a continuación, utilice el método de entrada de múltiples imágenes para el reconocimiento página por página.
Para más usos de la API Responses de OpenAI (como recuperar y gestionar respuestas completadas del modelo), consulte Compatible con OpenAI - Responses.

Pasar un archivo local (codificación Base64 o ruta de archivo)

Cargue archivos locales mediante codificación Base64 o una ruta de archivo directa. Seleccione el método según el tamaño del archivo y el tipo de SDK; consulte Cómo seleccionar un método de carga de archivos. Ambos métodos deben cumplir con los requisitos de archivo en Límites de imagen.
  • Usar codificación Base64
  • Usar ruta de archivo
Convierta el archivo en una cadena codificada en Base64 y luego pásela al modelo. Este método es adecuado para los SDK de OpenAI y DashScope, y solicitudes HTTP.
  1. Codifique el archivo: Convierta la imagen local en una cadena codificada en 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. Construya una Data URL con el siguiente formato: data:[MIME_type];base64,{base64_image}.
    1. Reemplace MIME_type con el tipo de medio real. Asegúrese de que el tipo coincida con el valor MIME Type en la tabla Límites de imagen, como image/jpeg o image/png.
    2. base64_image es la cadena codificada en Base64 generada en el paso anterior.
  3. Llamada al modelo: Pase la Data URL utilizando el parámetro image o image_url para llamar al modelo.
  • Pasar una ruta de archivo
  • Pasar una cadena codificada en Base64
El paso de una ruta de archivo solo se admite para llamadas realizadas con los SDK de Python y Java de DashScope. Este método no es compatible con DashScope HTTP ni métodos compatibles con 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/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"])

Más usos

Limitaciones

Límites de imagen

  • Dimensiones y relación de aspecto: Tanto el ancho como el alto de la imagen deben ser superiores a 10 píxeles. La relación de aspecto no debe exceder 200:1 o 1:200.
  • Píxeles totales: El modelo escala automáticamente las imágenes, por lo que no hay un límite estricto en el número total de píxeles. Sin embargo, una imagen no puede exceder 15.68 millones de píxeles.
  • Formatos de imagen compatibles
    • Para imágenes con una resolución inferior a 4K (3840x2160), se admiten los siguientes formatos:

      Formato de imagen

      Extensiones comunes

      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 imágenes con una resolución de 4K(3840x2160) a 8K(7680x4320), solo se admiten los formatos JPEG, JPG y PNG.
  • Tamaño de imagen:
    • Si proporciona una imagen mediante una URL pública o una ruta local: qwen3.5-ocr admite imágenes de hasta 20 MB; otras versiones admiten hasta 10 MB.
    • Si proporciona los datos en codificación Base64, la cadena codificada no puede exceder 10 MB.
    Consulte también: ¿Cómo comprimo una imagen o video al tamaño requerido? .

Límites del modelo

  • Mensaje del sistema: Qwen-OCR utiliza un System Message interno fijo y no acepta uno personalizado. Pase todas las instrucciones en el User Message.
  • Conversaciones de múltiples turnos: A partir de qwen3.5-ocr, se admiten conversaciones de múltiples turnos; puede enviar mensajes de texto de seguimiento sin una URL de imagen. qwen-vl-ocr-2025-11-20 y versiones anteriores procesan únicamente el mensaje más reciente y no conservan el contexto.
  • Riesgo de alucinación: El modelo puede alucinar si el texto en una imagen es demasiado pequeño o tiene baja resolución. Además, no se garantiza la precisión de las respuestas a preguntas no relacionadas con la extracción de texto.
  • Error al procesar archivos de texto:
    • Para archivos que contienen datos de imagen, siga las recomendaciones en Puesta en marcha para transformarlos en una secuencia de imágenes antes de procesarlos.
    • Para archivos con texto sin formato o datos estructurados, utilice Qwen-Long, un modelo que puede analizar texto largo.

Tipos de certificados y documentos admitidos

La tarea de extracción de información admite la extracción de datos estructurados de los siguientes certificados, recibos y permisos.
  • Pasaportes y documentos de viaje: pasaporte chino, pasaporte de Macao, permiso de viaje continental para residentes de Hong Kong y Macao, permiso de viaje continental para residentes de Taiwán y permiso de regreso a casa para residentes de Hong Kong y Macao.
  • Documentos vehiculares y facturas de venta: licencia de conducir, placa de identificación del vehículo, certificado de conformidad del vehículo, certificado de registro del vehículo, factura de venta de vehículos automotores y factura de venta de vehículos usados.
  • Facturas y recibos fiscales: factura ordinaria IVA (rollo), factura especial de monto fijo, factura general impresa por máquina, certificado de pago de impuestos y recibo de ingresos no tributarios centrales.
  • Recibos de transporte: boleto de tren de alta velocidad 12306, boleto de tren, boleto de barco, recibo de peaje de autopista y factura impresa por máquina de autopista.
  • Tarjetas financieras y recibos: tarjeta de crédito, letra de aceptación bancaria electrónica, recibo de pago y tarjeta de seguridad social.
  • Licencias comerciales y permisos: licencia comercial, licencia de negocio de alimentos, licencia de producción de alimentos, licencia de negocio farmacéutico y licencia de negocio de dispositivos médicos.
  • Certificado inmobiliario: certificado de propiedad inmobiliaria.
  • Tarjetas de identificación internacionales: ID de Hong Kong, ID de Macao, ID de Indonesia, ID de Tailandia, ID de Vietnam, ID de Malasia, ID de Filipinas, ID de India, ID de Turquía, ID de Pakistán, ID de México, ID del Reino Unido e ID de EE. UU.
  • Pasaportes internacionales y licencias de conducir: pasaporte indio, pasaporte de Singapur, pasaporte tailandés, pasaporte estadounidense, pasaporte australiano, pasaporte de los EAU, licencia de conducir filipina, licencia de conducir japonesa y licencia de conducir estadounidense.

Facturación y limitación de tasa

  • Facturación: Qwen-OCR es un modelo multimodal. El costo total se calcula de la siguiente manera: (Número de tokens de entrada × Precio unitario de entrada) + (Número de tokens de salida × Precio unitario de salida). Consulte las facturas o recargue su cuenta en la consola de Gastos y costos.
    • Cálculo de tokens de imagen: Utilice el siguiente código para estimar el uso de tokens de imagen. La facturación real se basa en la respuesta de la API.
      Fórmula: Tokens de imagen = (h_bar * w_bar) / token_pixels + 2.
      • h_bar * w_bar representa las dimensiones de la imagen escalada. El modelo preprocesa la imagen escalándola a un límite de píxeles específico. Este límite depende del valor del parámetro max_pixels.
      • token_pixels representa el valor de píxeles por Token.
        • Para qwen3.5-ocr, qwen-vl-ocr y qwen-vl-ocr-2025-11-20, este valor es fijo en 32*32 (que es 1024).
        • Para otros modelos, este valor es fijo en 28*28 (que es 784).
      Este código demuestra la lógica aproximada de escalado de imágenes que utiliza el modelo. Úselo para estimar el recuento de tokens para una imagen. La facturación real se basa en la respuesta de la 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}")
  • Limitación de tasa: Para los límites de tasa de Qwen-OCR, consulte Limitación de tasa.
  • Cuota gratuita (solo Singapur): Qwen-OCR proporciona una cuota gratuita de 1 millón de tokens. Esta cuota es válida por 90 días, a partir de la fecha en que active Model Studio o se apruebe su solicitud para utilizar el modelo.

Puesta en marcha

  • Preprocesamiento de imagen:
    • Asegúrese de que las imágenes de entrada sean claras, estén uniformemente iluminadas y no estén excesivamente comprimidas:
      • Almacene y transmita imágenes en un formato sin pérdida (por ejemplo, PNG) para evitar la pérdida de información.
      • Para mejorar la definición de la imagen, utilice algoritmos de eliminación de ruido, como filtrado de media o mediana, para suavizar imágenes con ruido.
      • Para corregir la iluminación desigual, utilice algoritmos como la ecualización adaptativa del histograma para ajustar el brillo y el contraste.
    • Imágenes sesgadas: Establezca enable_rotate: true en el SDK de DashScope para corregir la rotación antes del reconocimiento.
    • Imágenes muy pequeñas o muy grandes: Utilice min_pixels y max_pixels para controlar el escalado de imágenes.
      • min_pixels: Amplía las imágenes pequeñas para mejorar el detalle. Mantenga el valor predeterminado.
      • max_pixels: Evita que las imágenes de gran tamaño consuman demasiados tokens. El valor predeterminado cubre la mayoría de los casos. Auméntelo cuando se omita texto pequeño; esto incrementa el uso de tokens.
  • Validación de resultados: Los resultados de reconocimiento del modelo pueden contener errores. Para operaciones comerciales críticas, implemente un proceso de revisión manual o agregue reglas de validación para verificar la precisión de la salida del modelo. Por ejemplo, utilice la validación de formato para números de tarjetas de identificación y tarjetas bancarias.
  • Procesamiento por lotes: Para cargas de trabajo de alto volumen y no en tiempo real, utilice la API Batch para procesar trabajos de forma asíncrona a menor costo.

FAQ

Elija el mejor método de carga según el tipo de SDK, el tamaño del archivo y la estabilidad de la red.

Tipo

Especificaciones

DashScope SDK (Python, Java)

Compatible con OpenAI / HTTP de DashScope

Imagen

Mayor que 7 MB y menor que 10 MB

Pasar la ruta local

Solo se admiten URL públicas. Utilice Object Storage Service.

Menos de 7 MB

Pasar la ruta local

Codificación Base64

La codificación Base64 aumenta el tamaño de los datos. El tamaño del archivo original debe ser inferior a 7 MB.
El uso de una ruta local o la codificación Base64 ayuda a prevenir tiempos de espera de descarga en el servidor y mejora la estabilidad.
Después de que el modelo Qwen-OCR devuelva los resultados de localización de texto, utilice el código en el archivo draw_bbox.py para dibujar los cuadros de detección y sus etiquetas en la imagen original.
Cuando utiliza qwen3.5-ocr, si su Prompt personalizado contiene una estructura HTML completa, como <html><body>...</body></html>, el modelo puede seguir esa estructura y devolver el resultado de OCR en formato HTML en lugar de texto sin formato. La respuesta entonces parece vacía o aparenta contener etiquetas de estilo frontend. Una etiqueta simple, como una sola <br>, no activa este comportamiento.Para resolver este problema, utilice uno de los siguientes métodos:
  • Verifique si su Prompt contiene una estructura de etiquetas HTML completa. Si es así, reemplácela con una instrucción de texto sin formato e inténtelo de nuevo. Por ejemplo, cambie <html><body>Extract all text from the image</body></html> por Extract all text from the image.
  • Si no está seguro de si su Prompt afecta el formato de salida, omita el campo text para utilizar el Prompt predeterminado del modelo.
  • Utilice el modelo qwen3.7-plus en su lugar. Este modelo devuelve un resultado de texto sin formato incluso cuando pasa el mismo Prompt que contiene una estructura HTML.

Referencia de API

Para los parámetros de entrada y salida de Qwen-OCR, consulte la Qwen-OCR referencia de API.

Códigos de error

Si la llamada al modelo falla y devuelve un mensaje de error, consulte Códigos de error para su resolución.