Modern business systems, from retail checkout lanes to warehouse inventory tracking, rely heavily on barcode scanning, and Python-based solutions have become a popular choice due to their versatility and ease of use. In this article, we’ll explore how to read barcodes in Python using the Spire.Barcode for Python library, covering setup, scanning from image files or bytes, and customization options for improved accuracy.

Table of Contents:

• Python Library for Reading Barcodes
• Integrate Spire.Barcode into Your Python Application
• Read a Barcode from an Image File
• Read Multiple Barcodes from an Image File
• Read Barcodes from Image Bytes
• Adjust Barcode Recognition Settings
• Conclusion
• FAQs

Python Library for Reading Barcodes

Spire.Barcode for Python is a powerful library specifically crafted for creating and reading barcodes in Python applications. The library supports a variety of barcode formats, including:

• 1D Barcodes : Such as Code 128, Code 39, EAN-13, and UPC-A.
• 2D Barcodes : Including QR Code, DataMatrix, and PDF417.

Notable Features of Spire.Barcode

• Format Support : Capable of reading barcodes from various image formats, including PNG, JPG, BMP, GIF, and TIFF.
• Batch Scanning : Enables the detection of multiple barcodes within a single image file.
• Recognition Accuracy : Utilizes advanced algorithms to deliver reliable barcode detection.
• Customization : Allows users to specify barcode types and enable checksum verification for enhanced recognition efficiency.

This library provides the capability to read barcodes from both image files and bytes, along with extensive customization options to meet diverse requirements.

Integrate Spire.Barcode into Your Python Application

To get started with Spire.Barcode, you first need to install the library. You can do this via pip. Open your terminal and run:

pip install spire.barcode

Once you have installed the library, you will need a license key to unlock its full capabilities. You can obtain a trial license from our website. and set up the library in your Python script:

from spire.barcode import *

License.SetLicenseKey("your license key")

Now that you have the library in place, you can begin reading barcodes using Python.

Read a Barcode from an Image File in Python

Reading a single barcode from an image file is straightforward with Spire.Barcode. Here's how you can do it:

from spire.barcode import *

# Apply license key to unlock full capabilities
License.SetLicenseKey("your license key")

# Read barcode from an image file
result = BarcodeScanner.ScanOneFile("C:/Users/Administrator/Desktop/qr_code.png")

# Print the result
print(result)

Explanation

• License.SetLicenseKey() : Initializes the library with your license key.
• BarcodeScanner.ScanOneFile() : Reads a single barcode from the specified image file.
• The result is printed to the console, displaying the barcode's data.

Output:

Read Multiple Barcodes from an Image File in Python

If you need to read multiple barcodes from a single image file, Spire.Barcode makes this easy as well. Here’s an example:

from spire.barcode import *

# Apply license key to unlock full capabilities
License.SetLicenseKey("your license key")

# Read multiple barcodes from stream
results = BarcodeScanner.ScanFile("C:/Users/Administrator/Desktop/barcodes.jpg")

# Print results
print(results)

Explanation

• BarcodeScanner.ScanFile() : Scans the entire image for multiple barcodes.
• The results are stored as a list. Each element in the list contains the data from a detected barcode.

Output:

Read Barcodes from Image Bytes in Python

In addition to reading barcodes directly from files, Spire.Barcode for Python supports decoding barcodes from in-memory image bytes . This approach is useful when working with dynamically loaded images (e.g., from APIs, databases, or user uploads).

Here’s how to do it:

from spire.barcode import *

# Apply license key to unlock full capabilities
License.SetLicenseKey("your license key")

# Read an image file into bytes
image_path = "C:/Users/Administrator/Desktop/barcodes.jpg"
with open(image_path, "rb") as file:
    image_bytes = file.read()

# Wrap bytes in Spire.Barcode's Stream object
stream = Stream(image_bytes)

# Read one barcode from stream
# result = BarcodeScanner.ScanOneStream(stream)

# Read multiple barcodes from stream
results = BarcodeScanner.ScanStream(stream)

# Print results
print(results)

Explanation

• image_bytes: Raw binary data read from an image file (e.g., PNG, JPG) or other sources like APIs or databases.
• Stream (Spire.Barcode class): Converts image_bytes into an in-memory stream compatible with Spire.Barcode’s scanner.
• BarcodeScanner.ScanStream() : Scans the stream for barcodes and returns a list of detected barcodes.

Adjust Barcode Recognition Settings

The BarcodeScanner class provides various methods to customize barcode recognition settings. This can help improve detection accuracy and efficiency. Some of the key methods include:

• ScanOneFileBarCodeTypeIncludeCheckSum(fileName: str, barcodeType: BarCodeType, IncludeCheckSum: bool)
• ScanFileBarCodeTypeIncludeCheckSum(fileName: str, barcodeType: BarCodeType, IncludeCheckSum: bool)
• ScanOneStreamBarCodeTypeIncludeCheckSum(stream: Stream, barcodeType: BarCodeType, IncludeCheckSum: bool)
• ScanStreamBarCodeTypeIncludeCheckSum(stream: Stream, barcodeType: BarCodeType, IncludeCheckSum: bool)

Here’s an example of how to specify a barcode type and include checksum verification:

from spire.barcode import *

# Apply license key to unlock full capabilities
License.SetLicenseKey("your license key")

# Specify the barcode type (e.g., EAN13)
barcode_type = BarCodeType.EAN13

# Read a barcode from an image file with checksum included
result = BarcodeScanner.ScanOneFileBarCodeTypeIncludeCheckSum("C:/Users/Administrator/Desktop/EAN_13.png", barcode_type, True)

# Print the result
print(result)

Explanation

• BarcodeType : Specifies the type of barcode you want to scan.
• IncludeCheckSum (bool): Determines whether to verify the checksum during scanning. Setting it to True can help catch errors in data.

Conclusion

In this article, we explored how to read barcodes in Python using the Spire.Barcode library. We covered the setup process, reading single and multiple barcodes from image files, and reading from image bytes. Additionally, we discussed how to customize barcode detection settings for improved accuracy. With these tools at your disposal, you can easily integrate barcode scanning capabilities into your Python applications.

FAQs

Q1: What types of barcodes can I read with Spire.Barcode?

Spire.Barcode supports a wide range of barcode formats, including QR codes, UPC, EAN, Code 128, Code 39, and many others.

Q2: Do I need a license to use Spire.Barcode?

Yes, a license key is required to unlock the full functionality of the library. You can obtain a free 30-day trial license from our website.

Q3: Can I read barcodes from a webcam using Spire.Barcode?

While Spire.Barcode does not directly support webcam input, you can capture images from a webcam and then read barcodes from those images using the library.

Q4: How can I improve barcode scanning accuracy?

You can improve accuracy by specifying the barcode type and enabling checksum verification during scanning. Additionally, ensure that the images are clear and well-lit.

Q5. Can I generate barcodes using Spire.Barcode for Python?

Yes, Spire.Barcode supports both barcode recognition and generation. For detailed instructions, check out this tutorial: How to Generate Barcodes in Python: A Step-by-Step Guide.

Reading Word documents in Python is a common task for developers who work with document automation, data extraction, or content processing. Whether you're working with modern .docx files or legacy .doc formats, being able to open, read, and extract content like text, tables, and images from Word files can save time and streamline your workflows.

While many Python libraries support .docx, reading .doc files—the older binary format—can be more challenging. Fortunately, there are reliable methods for handling both file types in Python.

In this tutorial, you'll learn how to read Word documents (.doc and .docx) in Python using the Spire.Doc for Python library. We'll walk through practical code examples to extract text, images, tables, comments, lists, and even metadata. Whether you're building an automation script or a full document parser, this guide will help you work with Word files effectively across formats.

Table of Contents

• Why Read Word Documents Programmatically in Python?
• Install the Library for Parsing Word Documents in Python
• Read Text from Word DOC or DOCX in Python
  • Get Text from Entire Document
  • Get Text from Specific Section or Paragraph
• Read Specific Elements from a Word Document in Python
  • Extract Images
  • Get Table Data
  • Read Lists
  • Extract Comments
  • Retrieve Metadata (Document Properties)
• Conclusion
• FAQs

Why Read Word Documents Programmatically in Python?

Reading Word files using Python allows for powerful automation of content processing tasks, such as:

• Extracting data from reports, resumes, or forms.
• Parsing and organizing content into databases or dashboards.
• Converting or analyzing large volumes of Word documents.
• Integrating document reading into web apps, APIs, or back-end systems.

Programmatic reading eliminates manual copy-paste workflows and ensures consistent and scalable results.

Install the Library for Parsing Word Documents in Python

To read .docx and .doc files in Python, you need a library that can handle both formats. Spire.Doc for Python is a versatile and easy-to-use library that lets you extract text, images, tables, comments, lists, and metadata from Word documents. It runs independently of Microsoft Word, so Office installation is not required.

To get started, install Spire.Doc easily with pip:

pip install Spire.Doc

Read Text from Word DOC or DOCX in Python

Extracting text from Word documents is a common requirement in many automation and data processing tasks. Depending on your needs, you might want to read the entire content or focus on specific sections or paragraphs. This section covers both approaches.

Get Text from Entire Document

When you need to retrieve the complete textual content of a Word document — for tasks like full-text indexing or simple content export — you can use the Document.GetText() method. The following example demonstrates how to load a Word file, extract all text, and save it to a file:

from spire.doc import *

# Load the Word .docx or .doc file
document = Document()
document.LoadFromFile("sample.docx")

# Get all text
text = document.GetText()

# Save to a text file
with open("extracted_text.txt", "w", encoding="utf-8") as file:
    file.write(text)

document.Close()

Get Text from Specific Section or Paragraph

Many documents, such as reports or contracts, are organized into multiple sections. Extracting text from a specific section enables targeted processing when you need content from a particular part only. By iterating through the paragraphs of the selected section, you can isolate the relevant text:

from spire.doc import *

# Load the Word .docx or .doc file
document = Document()
document.LoadFromFile("sample.docx")

# Access the desired section
section = document.Sections[0]

# Get text from the paragraphs of the section
with open("paragraphs_output.txt", "w", encoding="utf-8") as file:
    for paragraph in section.Paragraphs:
        file.write(paragraph.Text + "\n")

document.Close()

Read Specific Elements from a Word Document in Python

Beyond plain text, Word documents often include rich content like images, tables, comments, lists, metadata, and more. These elements can easily be programmatically accessed and extracted.

Extract Images

Word documents often embed images like logos, charts, or illustrations. To extract these images:

• Traverse each paragraph and its child objects.
• Identify objects of type DocPicture.
• Retrieve the image bytes and save them as separate files.

from spire.doc import *
import os

# Load the Word document
document = Document()
document.LoadFromFile("sample.docx")

# Create a list to store image byte data
images = []

# Iterate over sections
for s in range(document.Sections.Count):
    section = document.Sections.get_Item(s)

    # Iterate over paragraphs
    for p in range(section.Paragraphs.Count):
        paragraph = section.Paragraphs.get_Item(p)

        # Iterate over child objects
        for c in range(paragraph.ChildObjects.Count):
            obj = paragraph.ChildObjects[c]
            # Extract image data
            if isinstance(obj, DocPicture):
                picture = obj
                # Get image bytes
                dataBytes = picture.ImageBytes
                # Store in the list
                images.append(dataBytes)

# Create the output directory if it doesn't exist
output_folder = "ExtractedImages"
os.makedirs(output_folder, exist_ok=True)

# Save each image from byte data
for i, item in enumerate(images):
    fileName = f"Image-{i+1}.png"
    with open(os.path.join(output_folder, fileName), 'wb') as imageFile:
        imageFile.write(item)

# Close the document
document.Close()

Get Table Data

Tables organize data such as schedules, financial records, or lists. To extract all tables and their content:

• Loop through tables in each section.
• Loop through rows and cells in each table.
• Traverse over each cell’s paragraphs and combine their texts.
• Save the extracted table data in a readable text format.

from spire.doc import *
import os

# Load the Word document
document = Document()
document.LoadFromFile("tables.docx")

# Ensure output directory exists
output_dir = "output/Tables"
os.makedirs(output_dir, exist_ok=True)

# Loop through each section
for s in range(document.Sections.Count):
    section = document.Sections.get_Item(s)
    tables = section.Tables

    # Loop through each table in the section
    for i in range(tables.Count):
        table = tables.get_Item(i)
        table_data = ""

        # Loop through each row
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)

            # Loop through each cell
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text = ""

                # Combine text from all paragraphs in the cell
                for p in range(cell.Paragraphs.Count):
                    para_text = cell.Paragraphs.get_Item(p).Text
                    cell_text += para_text + " "

                table_data += cell_text.strip()

                # Add tab between cells (except after the last cell)
                if k < row.Cells.Count - 1:
                    table_data += "\t"
            table_data += "\n"

        # Save the table data to a separate text file
        output_path = os.path.join(output_dir, f"WordTable_{s+1}_{i+1}.txt")
        with open(output_path, "w", encoding="utf-8") as output_file:
            output_file.write(table_data)

# Close the document
document.Close()

Read Lists

Lists are frequently used to structure content in Word documents. This example identifies paragraphs formatted as list items and writes the list marker together with the text to a file.

from spire.doc import *

# Load the Word document
document = Document()
document.LoadFromFile("sample.docx")

# Open a text file for writing the list items
with open("list_items.txt", "w", encoding="utf-8") as output_file:

    # Iterate over sections
    for s in range(document.Sections.Count):
        section = document.Sections.get_Item(s)

        # Iterate over paragraphs
        for p in range(section.Paragraphs.Count):
            paragraph = section.Paragraphs.get_Item(p)

            # Check if the paragraph is a list
            if paragraph.ListFormat.ListType != ListType.NoList:
                # Write the combined list marker and paragraph text to file
                output_file.write(paragraph.ListText + paragraph.Text + "\n")

# Close the document
document.Close()

Extract Comments

Comments are typically used for collaboration and feedback in Word documents. This code retrieves all comments, including the author and content, and saves them to a file with clear formatting for later review or audit.

from spire.doc import *

# Load the Word .docx or .doc document
document = Document()
document.LoadFromFile("sample.docx")

# Open a text file to save comments
with open("extracted_comments.txt", "w", encoding="utf-8") as output_file:

    # Iterate over the comments
    for i in range(document.Comments.Count):
        comment = document.Comments.get_Item(i)

        # Write comment header with comment number
        output_file.write(f"Comment {i + 1}:\n")

        # Write comment author
        output_file.write(f"Author: {comment.Format.Author}\n")

        # Extract full comment text by concatenating all paragraph texts
        comment_text = ""
        for j in range(comment.Body.Paragraphs.Count):
            paragraph = comment.Body.Paragraphs[j]
            comment_text += paragraph.Text + "\n"

        # Write the comment text
        output_file.write(f"Content: {comment_text.strip()}\n")

        # Add a blank line between comments
        output_file.write("\n")

# Close the document
document.Close()

Retrieve Metadata (Document Properties)

Metadata provides information about the document such as author, title, creation date, and modification date. This code extracts common built-in properties for reporting or cataloging purposes.

from spire.doc import *

# Load the Word .docx or .doc document
document = Document()
document.LoadFromFile("sample.docx")

# Get the built-in document properties
props = document.BuiltinDocumentProperties

# Open a text file to write the properties
with open("document_properties.txt", "w", encoding="utf-8") as output_file:
    output_file.write(f"Title: {props.Title}\n")
    output_file.write(f"Author: {props.Author}\n")
    output_file.write(f"Subject: {props.Subject}\n")
    output_file.write(f"Created: {props.CreateDate}\n")
    output_file.write(f"Modified: {props.LastSaveDate}\n")

# Close the document
document.Close()

Conclusion

Reading both .doc and .docx Word documents in Python is fully achievable with the right tools. With Spire.Doc, you can:

• Read text from the entire document, any section or paragraph.
• Extract tables and process structured data.
• Export images embedded in the document.
• Extract comments and lists from the document.
• Work with both modern and legacy Word formats without extra effort.

Try Spire.Doc today to simplify your Word document parsing workflows in Python!

FAQs

Q1: How do I read a Word DOC or DOCX file in Python?

A1: Use a Python library like Spire.Doc to load and extract content from Word files.

Q2: Do I need Microsoft Word installed to use Spire.Doc?

A2: No, it works without any Office installation.

Q3: Can I generate or update Word documents with Spire.Doc?

A3: Yes, Spire.Doc not only allows you to read and extract content from Word documents but also provides powerful features to create, modify, and save Word files programmatically.

Get a Free License

To fully experience the capabilities of Spire.Doc for Python without any evaluation limitations, you can request a free 30-day trial license.

Text boxes are one of the most common elements used to display content in PowerPoint. However, as slides get frequently edited, you may end up with a clutter of unnecessary text boxes. Manually deleting them can be time-consuming. This guide will show you how to delete text boxes in PowerPoint using Python. Whether you want to delete all text boxes, remove a specific one, or clean up only the empty ones, you'll learn how to do it in just a few lines of code — saving time and making your workflow much more efficient.

• Install the Python Library
• Delete All Text Boxes
• Delete a Specific Text Box
• Delete Empty Text Boxes
• Compare All Three Methods
• FAQs

Install the Python Library for PowerPoint Automation

To make this task easier, installing the right Python library is essential. In this guide, we’ll use Spire.Presentation for Python to demonstrate how to automate the removal of text boxes in a PowerPoint file. As a standalone third-party component, Spire.Presentation doesn’t require Microsoft Office to be installed on your machine. Its API is simple and beginner-friendly, and installation is straightforward — just run:

pip install spire.presentation

Alternatively, you can download the package for custom installation. A free version is also available, which is great for small projects and testing purposes.

How to Delete All Text Boxes in PowerPoint

Let’s start by looking at how to delete all text boxes — a common need when you're cleaning up a PowerPoint template. Instead of adjusting each text box and its content manually, it's often easier to remove them all and then re-add only what you need. With the help of Spire.Presentation, you can use the IAutoShape.Remove() method to remove text boxes in just a few lines of code. Let’s see how it works in practice. Steps to delete all text boxes in a PowerPoint presentation with Python:

• Create an instance of Presentation class, and load a sample PowerPoint file.
• Loop through all slides and all shapes on slides, and check if the shape is IAutoShape and if it is a text box.
• Remove text boxes in the PowerPoint presentation through IAutoShape.Remove() method.
• Save the modified PowerPoint file.

The following is a complete code example for deleting all text boxes in a PowerPoint presentation:

from spire.presentation import *

# Create a Presentation object and load a PowerPoint file
presentation = Presentation()
presentation.LoadFromFile("E:/Administrator/Python1/input/pre1.pptx")

# Loop through all slides 
for slide in presentation.Slides:
    # Loop through all shapes in the slide
    for i in range(slide.Shapes.Count - 1, -1, -1):
        shape = slide.Shapes[i]
        # Check if the shape is IAutoShape and is a text box
        if isinstance(shape, IAutoShape) and shape.IsTextBox:
            # Remove the shape
            slide.Shapes.Remove(shape)

# Save the modified presentation
presentation.SaveToFile("E:/Administrator/Python1/output/RemoveAllTextBoxes.pptx", FileFormat.Pptx2013)
presentation.Dispose()

Warm Tip: When looping through shapes, use reverse order to avoid skipping any elements after deletion.

How to Delete a Specific Text Box in PowerPoint

If you only need to remove a few specific text boxes — for example, the first text box on the second slide — this method is perfect for you. In Python, you can first locate the target slide by its index, then identify the text box by its content, and finally remove it. This approach gives you precise control when you know exactly which text box needs to be deleted. Let’s walk through how to do this in practice. Steps to delete a specific text box in PowerPoint using Python:

• Create an object of Presentation class and read a PowerPoint document.
• Get a slide using Presentation.Slides[] property.
• Loop through each shape on the slide and check if it is the target text box.
• Remove the text box through IAutoShape.Remove() method.
• Save the modified PowerPoint presentation.

The following code demonstrates how to delete a text box with the content "Text Box 1" on the second slide of the presentation:

from spire.presentation import *

# Create a new Presentation object and load a PowerPoint file 
presentation = Presentation()
presentation.LoadFromFile("E:/Administrator/Python1/input/pre1.pptx")

# Get the second slide
slide = presentation.Slides[1]

# Loop through all shapes on the slide
for i in range(slide.Shapes.Count - 1, -1, -1):
    shape = slide.Shapes[i]
    # Check if the shape is a text box and its text is "Text Box 1"
    if isinstance(shape, IAutoShape) and shape.IsTextBox:
        if shape.TextFrame.Text.strip() == "Text Box 1":
            slide.Shapes.Remove(shape)

# Save the modified presentation
presentation.SaveToFile("E:/Administrator/Python1/output/RemoveSpecificTextbox.pptx", FileFormat.Pptx2013)
presentation.Dispose()

How to Delete Empty Text Boxes in PowerPoint

Another common scenario is removing all empty text boxes from a PowerPoint file — especially when you're cleaning up slides exported from other tools or merging multiple presentations and want to get rid of unused placeholders. Instead of checking each slide manually, automating the process with Python allows you to quickly remove all blank text boxes and keep only the meaningful content. It’s a far more efficient approach. Steps to delete empty text boxes in PowerPoint file using Python:

• Create an object of Presentation class, and load a PowerPoint file.
• Loop through all slides and all shapes on slides.
• Check if the shape is a text box and is empty.
• Remove text boxes in the PowerPoint presentation through IAutoShape.Remove() method.
• Save the modified PowerPoint file.

Here's the code example that shows how to delete empty text boxes in a PowerPoint presentation:

from spire.presentation import *

# Create a Presentation instance and load a sample file
presentation = Presentation()
presentation.LoadFromFile("E:/Administrator/Python1/input/pre1.pptx")

# Loop through each slide
for slide in presentation.Slides:
    # Iterate through shapes 
    for i in range(slide.Shapes.Count - 1, -1, -1):
        shape = slide.Shapes[i]
        # Check if the shape is a textbox and its text is empty
        if isinstance(shape, IAutoShape) and shape.IsTextBox:
            text = shape.TextFrame.Text.strip()
            # Remove the shape if it is empty
            if not text:
                slide.Shapes.Remove(shape)

# Save the result file 
presentation.SaveToFile("E:/Administrator/Python1/output/RemoveEmptyTextBoxes.pptx", FileFormat.Pptx2013)
presentation.Dispose()

Compare All Three Methods: Which One Should You Use?

Each of the three methods we've discussed has its own ideal use case. If you're still unsure which one fits your needs after reading through them, the table below will help you compare them at a glance — so you can quickly pick the most suitable solution.

Conclusion and Best Practice

Whether you're refreshing templates, fine-tuning individual slides, or cleaning up empty placeholders, automating PowerPoint with Python can save you hours of manual work. Choose the method that fits your workflow best — and start making your presentations cleaner and more efficient today.

FAQs about Deleting Text Boxes in PowerPoint

Q1: Why can't I delete a text box in PowerPoint?
A: One common reason is that the text box is placed inside the Slide Master layout. In this case, it can’t be selected or deleted directly from the normal slide view. You’ll need to go to the View → Slide Master tab, locate the layout, and delete it from there.

Q2: How can I delete a specific text box using Python?
A: You can locate the specific text box by accessing the slide and then searching for the shape based on its index or text content. Once identified, use the IAutoShape.Remove() method to delete it. This is useful when you know exactly which text box needs to be removed.

Q3: Is it possible to remove a text box without deleting the content?
A: If you want to keep the content but remove the text box formatting (like borders or background), you can extract the text before deleting the shape and reinsert it elsewhere — for example, as a plain paragraph. However, PowerPoint doesn’t natively support detaching text from its container without removing the shape.

Extracting text from images using Python is a widely used technique in OCR-driven workflows such as document digitization, form recognition, and invoice processing. Many important documents still exist only as scanned images or photos, making it essential to convert visual information into machine-readable text.

With the help of powerful Python libraries, you can easily perform text extraction from image files with Python — even for multilingual documents or layout-sensitive content. In this article, you’ll learn how to use Python to extract text from an image, through practical OCR examples, useful tips, and proven methods to improve recognition accuracy.

The guide is structured as follows:

• Powerful Python Library to Extract Text from Image
• Step-by-Step: Python Code to Extract Text from Image
  • Basic OCR Text Extraction (Image to Plain Text)
  • Extract Text from Image with Coordinates
• Real-World Use Cases for Text Extraction from Images
• Supported Languages and Image Formats
• How to Improve OCR Accuracy (Best Practices)
• FAQ

Powerful Python Library to Extract Text from Image

Spire.OCR for Python is a powerful OCR library for Python, especially suited for applications requiring structured layout extraction and multilingual support. This Python OCR engine supports:

• Text recognition with layout and position information
• Multilingual support (English, Chinese, French, etc.)
• Supports multiple image formats including JPG, PNG, BMP, GIF, and TIFF

Setup: Install Dependencies and OCR Models

Before extracting text from images using Python, you need to install the spire.ocr library and download the OCR model files compatible with your operating system.

1. Install the Spire.OCR Python Package

Use pip to install the Spire.OCR for Python package:

pip install spire.ocr

2. Download the OCR Model Package

Download the OCR model files based on your OS:

• Windows: win-x64.zip
• Linux: linux.zip
• macOS: mac.zip
• linux_aarch: linux_aarch.zip

After downloading, extract the files and set the model path in your Python script when configuring the OCR engine.

Step-by-Step: Python Code to Extract Text from Image

In this section, we’ll walk through different ways to extract text from images using Python — starting with a simple plain-text extraction, and then moving to more advanced structured recognition.

Basic OCR Text Extraction (Image to Plain Text)

Here’s how to extract plain text from an image using Python:

from spire.ocr import *

# Create OCR scanner instance
scanner = OcrScanner()

# Configure OCR model path and language
configureOptions = ConfigureOptions()
configureOptions.ModelPath = r'D:\OCR\win-x64'
configureOptions.Language = 'English'
scanner.ConfigureDependencies(configureOptions)

# Perform OCR on the image
scanner.Scan(r'Sample.png')

# Save extracted text to file
text = scanner.Text.ToString()
with open('output.txt', 'a', encoding='utf-8') as file:
    file.write(text + '\n')

Optional: Clean and Preprocess Extracted Text (Post-OCR)

After OCR, the output may contain empty lines or noise. This snippet shows how to clean the text:

# Clean extracted text: remove empty or short lines
clean_lines = [line.strip() for line in text.split('\n') if len(line.strip()) > 2]
cleaned_text = '\n'.join(clean_lines)

# Save to a clean version
with open('output_clean.txt', 'w', encoding='utf-8') as file:
    file.write(cleaned_text)

Use Case: Useful for post-processing OCR output before feeding into NLP tasks or database storage.

Here’s an example of plain-text OCR output using Spire.OCR:

Extract Text from Image with Coordinates

In forms or invoices, you may need both text content and layout. The code below outputs each block’s bounding box info:

from spire.ocr import *

scanner = OcrScanner()

configureOptions = ConfigureOptions()
configureOptions.ModelPath = r'D:\OCR\win-x64'
configureOptions.Language = 'English'
scanner.ConfigureDependencies(configureOptions)

scanner.Scan(r'sample.png')
text = scanner.Text

# Extract block-level text with position
block_text = ""
for block in text.Blocks:
    rectangle = block.Box
    block_info = f'{block.Text} -> x: {rectangle.X}, y: {rectangle.Y}, w: {rectangle.Width}, h: {rectangle.Height}'
    block_text += block_info + '\n'

with open('output.txt', 'a', encoding='utf-8') as file:
    file.write(block_text + '\n')

Extract Text from Multiple Images in a Folder

You can also batch process a folder of images:

import os
from spire.ocr import *

def extract_text_from_folder(folder_path, model_path):
    scanner = OcrScanner()
    config = ConfigureOptions()
    config.ModelPath = model_path
    config.Language = 'English'
    scanner.ConfigureDependencies(config)

    for filename in os.listdir(folder_path):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
            image_path = os.path.join(folder_path, filename)
            scanner.Scan(image_path)
            text = scanner.Text.ToString()

            # Save each result as a separate file
            output_file = os.path.splitext(filename)[0] + '_output.txt'
            with open(output_file, 'w', encoding='utf-8') as f:
                f.write(text)

# Example usage
extract_text_from_folder(r'D:\images', r'D:\OCR\win-x64')

The recognized text blocks with position information are shown below:

Real-World Use Cases for Text Extraction from Images

Python-based OCR can be applied in:

• ✅ Invoice and receipt scanning
• ✅ Identity document OCR (passport, license)
• ✅ Business card digitization
• ✅ Form and survey data extraction
• ✅ Multilingual document indexing

Tip: For text extraction from PDF documents instead of images, you might also want to explore this tutorial on extracting text from PDF using Python.

Supported Languages and Image Formats

Spire.OCR supports multiple languages and a wide range of image formats for broader application scenarios.

Supported Languages:

• English
• Simplified / Traditional Chinese
• French
• German
• Japanese
• Korean

You can set the language using configureOptions.Language.

Supported Image Formats:

• JPG / JPEG
• PNG
• BMP
• GIF
• TIFF

How to Improve OCR Accuracy (Best Practices)

For better OCR text extraction from images using Python, follow these tips:

• Use high-resolution images (≥300 DPI)
• Preprocess with grayscale, thresholding, or denoising
• Avoid skewed or noisy scans
• Match the OCR language with the image content

FAQ

How to extract text from an image in Python code?

To extract text from an image using Python, you can use an OCR library like Spire.OCR for Python. With just a few lines of Python code, you can recognize text in scanned documents or photos and convert it into editable, searchable content.

What is the best Python library to extract text from image?

Spire.OCR for Python is a powerful Python OCR library that offers high-accuracy recognition, multilingual support, and layout-aware output. It also works seamlessly with Spire.Office components, allowing full automation — such as saving extracted text to Excel, Word, or searchable PDFs. You can also explore open-source tools to build your Python text extraction from image projects, depending on your specific needs and preferences.

How to extract data (including position) from image in Python?

When performing text extraction from image using Python, Spire.OCR provides not just the recognized text, but also bounding box coordinates for each block — ideal for processing structured content like tables, forms, or receipts.

How to extract text using Python from scanned PDF files?

To perform text extraction from scanned PDF files using Python, you can first convert each PDF page into an image, then apply OCR using Spire.OCR for Python. For this, we recommend using Spire.PDF for Python — it allows you to save PDF pages as images or directly extract embedded images from scanned PDFs, making it easy to integrate with your OCR pipeline.

Conclusion: Efficient Text Extraction from Images with Python

Thanks to powerful libraries like Spire.OCR, text extraction from images in Python is both fast and reliable. Whether you're processing receipts or building an intelligent OCR pipeline, this approach gives you precise control over both content and layout.

If you want to remove usage limitations of Spire.OCR for Python, you can apply for a free temporary license.