Manual PDF form filling remains a tedious and error-prone task in business and administrative workflows, despite the ubiquity of digital tools. This article explores an AI-driven solution to automate the process using Python and large language models (LLMs) like OpenAI’s GPT-4o. By extracting form fields, leveraging contextual AI analysis, and dynamically populating PDFs, the method reduces human intervention to near zero - demonstrated through real-world examples like the IRS W-9 and California’s TR-205 forms. While results vary depending on PDF structure and field clarity, the approach highlights the transformative potential of AI in document automation, offering scalability, speed, and a framework for overcoming challenges like ambiguous field labeling. Discover how even imperfect AI today paves the way for tomorrow’s seamless automation. Context Context This article grew out of my work developing Instafill.ai, a tool designed to streamline PDF form automation for businesses and individuals. While Instafill.ai now handles complex workflows (like legal documents and tax forms), its earliest iteration was a humble Python script - similar to the one I’ll explore here. By sharing this open-source approach, I aim to empower developers to build their own solutions. Think of this as a behind-the-scenes look at how Instafill.ai core technology started - and a roadmap for your experiments. Interactive PDF documents are widely used in business and education, but manually filling them out can be a real challenge. The repetitive nature of this process and the risk of errors during manual data entry often lead to wasted time and frustration. Automation can be a game-changer, significantly reducing document processing time and minimizing errors. My company team aimed to address the pain points of users dealing with PDF forms and we asked ourselves three key questions: Are there existing products today that solve the problems of manually filling out such forms?
How can we solve these problems, and what additional value would our potential user gain if alternative products already exist?
Can the task of filling PDF forms be entirely delegated to artificial intelligence? Are there existing products today that solve the problems of manually filling out such forms? How can we solve these problems, and what additional value would our potential user gain if alternative products already exist? Can the task of filling PDF forms be entirely delegated to artificial intelligence? To be honest, the last question remains relevant even now. However, the rapid advancement of large language models allows us to confidently bet on reducing human involvement in monotonous PDF form filling to zero. This idea forms the foundation of the solution I will discuss further in this article. Solution Architecture: From Reading PDFs to Filling Forms Using AI Solution Architecture: From Reading PDFs to Filling Forms Using AI Let’s get to the core. The main concept of the solution involves: Reading the PDF form — extracting text and form fields.
Using an artificial intelligence model to analyze and populate the fields.
Updating the PDF file with new values. Reading the PDF form — extracting text and form fields. Using an artificial intelligence model to analyze and populate the fields. Updating the PDF file with new values. Overall, nothing too complicated, right? This can be implemented using any programming language, but we chose Python specifically because it’s flexible, versatile, and efficient for writing code and conducting experiments. After all, we constantly need to test new hypotheses and make quick decisions based on the results. By the end, you’ll also have a script ready to use on your PDF forms. Implementation and Step-by-Step Instructions 1. Reading the PDF The script starts by reading the PDF file to extract its text and form fields. The text from the PDF document provides the AI model with general information about the form and its purpose. This sets the context in which the AI model will operate to fill in the required fields. def extract_pdf_text(pdf_bytes: bytes) -> str:
    pdf_text = ''
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)
    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        text_page = page.get_textpage()
        pdf_text += text_page.extractText()

    return pdf_text def extract_pdf_text(pdf_bytes: bytes) -> str:
    pdf_text = ''
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)
    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        text_page = page.get_textpage()
        pdf_text += text_page.extractText()

    return pdf_text Equally important is extracting as much information as possible about these fields and saving it in a format understandable to the AI model. This improves the quality of the output because the more context and details we provide to the AI, the higher the likelihood of generating the desired result. Large language models tend to always return some output, but the quality can be questionable. Our goal is to minimize the frequency of hallucinations. def extract_pdf_fields(pdf_bytes: bytes) -> list[dict]:
    form_fields = []
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)

    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        widget_list = page.widgets()
        if widget_list:
            for widget in widget_list:
                form_fields.append({
                    'name': widget.field_name,
                    'label': widget.field_label,
                    'type': widget.field_type_string,
                    'max_length': widget.text_maxlen
                })

    return form_fields def extract_pdf_fields(pdf_bytes: bytes) -> list[dict]:
    form_fields = []
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)

    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        widget_list = page.widgets()
        if widget_list:
            for widget in widget_list:
                form_fields.append({
                    'name': widget.field_name,
                    'label': widget.field_label,
                    'type': widget.field_type_string,
                    'max_length': widget.text_maxlen
                })

    return form_fields 2. Delegating the Work to AI Before using the AI to populate the form fields, the script generates a prompt. The quality of this prompt determines whether the "magic" happens. The prompt contains general instructions and accepts PDF components (extracted in the previous step) and unstructured data as parameters. This data is the source of information needed to fill the form. For simplicity, the script reads it from a text file, but in general, it could be any format: PDF, DOCX, JPG, etc. def fill_fields_prompt(pdf_text: str, fields: list[dict], source_info: str) -> str:
    return f"""
        You are an automated PDF forms filler.
        Your job is to fill the following form fields using the provided materials.
        Field keys will tell you which values they expect:
        {json.dumps(fields)}

        Materials:
        - Text extracted from the PDF form, delimited by <>:
        <{pdf_text}>

        - Source info attached by user, delimited by ##:
        #{source_info}#
        
        Output a JSON object with key-value pairs where:
        - key is the 'name' of the field,
        - value is the field value you assigned to it.
    """ def fill_fields_prompt(pdf_text: str, fields: list[dict], source_info: str) -> str:
    return f"""
        You are an automated PDF forms filler.
        Your job is to fill the following form fields using the provided materials.
        Field keys will tell you which values they expect:
        {json.dumps(fields)}

        Materials:
        - Text extracted from the PDF form, delimited by <>:
        <{pdf_text}>

        - Source info attached by user, delimited by ##:
        #{source_info}#
        
        Output a JSON object with key-value pairs where:
        - key is the 'name' of the field,
        - value is the field value you assigned to it.
    """ I chose OpenAI and the GPT-4o model as the AI provider. It is sufficiently intelligent and fast. You can experiment with other providers and models, but remember to tailor the prompt for each LLM. Prompt engineering is critical at this stage. After the API call (shown below), we’ll have a dictionary of <field name>:<field value>, ready for the next step. OpenAI <field name>:<field value> def call_openai(prompt: str, gpt_model: str = 'gpt-4o'):
    response =  openai_client.chat.completions.create(
        model=gpt_model,
        messages=[{'role': 'system', 'content': prompt}],
        response_format={"type": "json_object"},
        timeout=TIMEOUT,
        temperature=0
    )
    
    response_data = response.choices[0].message.content.strip()
    return json.loads(response_data) def call_openai(prompt: str, gpt_model: str = 'gpt-4o'):
    response =  openai_client.chat.completions.create(
        model=gpt_model,
        messages=[{'role': 'system', 'content': prompt}],
        response_format={"type": "json_object"},
        timeout=TIMEOUT,
        temperature=0
    )
    
    response_data = response.choices[0].message.content.strip()
    return json.loads(response_data) 3. Filling the PDF The final touch is populating the PDF with the values the AI has generated for the form fields. def fill_pdf_fields(pdf_bytes: bytes, field_values: dict) -> io.BytesIO:
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)
    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        widget_list = page.widgets()

        if widget_list:
            for widget in widget_list:
                field_name = widget.field_name
                if field_name in field_values:
                    widget.field_value = field_values[field_name]
                    widget.update()
                    
    output_stream = io.BytesIO()
    pdf_document.save(output_stream)
    output_stream.seek(0)

    return output_stream def fill_pdf_fields(pdf_bytes: bytes, field_values: dict) -> io.BytesIO:
    pdf_document = fitz.open(PDF_EXT, pdf_bytes)
    for page_num in range(len(pdf_document)):
        page = pdf_document.load_page(page_num)
        widget_list = page.widgets()

        if widget_list:
            for widget in widget_list:
                field_name = widget.field_name
                if field_name in field_values:
                    widget.field_value = field_values[field_name]
                    widget.update()
                    
    output_stream = io.BytesIO()
    pdf_document.save(output_stream)
    output_stream.seek(0)

    return output_stream Testing the Solution First and foremost, our product targets a U.S. audience, so as an example, I used the IRS W-9 form — a common document in the United States used to collect taxpayer identification information. This form is often required for freelancing, contractual agreements, and various financial transactions. Given its widespread use, it serves as an ideal example to demonstrate how our solution works. IRS W-9 For filling out this form, I used the following test data: 1. personal info
   john smith
   222 Victory St, 125
   San Francisco, CA, 94111

 2. business info
   BOTMAKERS, LLC
   has foreign partners
   account numbers: 1234567890, 0987654321
   tin: 123456789

 3. requester
   jane smith
   87 Independence St 1. personal info
   john smith
   222 Victory St, 125
   San Francisco, CA, 94111

 2. business info
   BOTMAKERS, LLC
   has foreign partners
   account numbers: 1234567890, 0987654321
   tin: 123456789

 3. requester
   jane smith
   87 Independence St Now for the most interesting part: let’s look at the filled-out form and analyze the quality of the solution’s work. We see that all fields are populated. Ignoring quality for now, our initial conclusion is that the generative AI handled its task. Let’s dig deeper into what it generated: there are clear successes and failures. Some fields (highlighted in green) are filled correctly, while others (highlighted in red) look like someone typed them blindly. Let’s explore why this happened. Here are some of the fields extracted from the PDF form (only a subset is shown; others follow the same pattern): {
    "name" : "topmostSubform[0].Page1[0].Boxes3a-b_ReadOrder[0].c1_2[0]",
    "label" : null,
    "type" : "CheckBox",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].f1_05[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].f1_06[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].Address_ReadOrder[0].f1_07[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
} {
    "name" : "topmostSubform[0].Page1[0].Boxes3a-b_ReadOrder[0].c1_2[0]",
    "label" : null,
    "type" : "CheckBox",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].f1_05[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].f1_06[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "topmostSubform[0].Page1[0].Address_ReadOrder[0].f1_07[0]",
    "label" : null,
    "type" : "Text",
    "max_length" : 0
} The field name is a critical parameter for the AI when filling in values. However, in this case, we face a problem: the names lack sufficient information to unambiguously determine the expected values for these fields. This explains the unsatisfactory results. Let’s try filling out another form — TR-205 (Request for Trial by Written Declaration). This document is used in California to submit a request for a trial by written declaration. It allows drivers to contest traffic violations without appearing in court. TR-205 I used the following test data to fill it out: Court:
 SUPERIOR COURT OF CALIFORNIA
 100 NORTH STATE STREET
 UKIAH CA 95482
 BRANCH #23480

 Citation: KV19133
 Case: 231N07977

 Defendant:
 John Smith
 1234 Main Street, Apt. 101

 Due date: 07/21/24
 Bail amount: $441
 Date mailed: 06/21/24

 Evidence:
  - photographs (5)
  - witness testimony

 Statement of facts: I increased my speed to avoid a possible traffic accident due to a truck in the middle of the road.

 Today: 06/21/24 Court:
 SUPERIOR COURT OF CALIFORNIA
 100 NORTH STATE STREET
 UKIAH CA 95482
 BRANCH #23480

 Citation: KV19133
 Case: 231N07977

 Defendant:
 John Smith
 1234 Main Street, Apt. 101

 Due date: 07/21/24
 Bail amount: $441
 Date mailed: 06/21/24

 Evidence:
  - photographs (5)
  - witness testimony

 Statement of facts: I increased my speed to avoid a possible traffic accident due to a truck in the middle of the road.

 Today: 06/21/24 And here’s the result: Notice that the script performed better with this form. All provided information landed in the “correct” fields. As you might guess, the difference lies in how these fields are stored in the PDF. Compare them to the previous example: {
    "name" : "TR-205[0].Page1[0].P1Caption[0].CitationNumber[0].CitationNumber[0]",
    "label" : "CITATION NUMBER:",
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "TR-205[0].Page1[0].P1Caption[0].CaseNumber[0].CaseNumber[0]",
    "label" : "CASE NUMBER:",
    "type" : "Text",
    "max_length" : 0
} {
    "name" : "TR-205[0].Page1[0].P1Caption[0].CitationNumber[0].CitationNumber[0]",
    "label" : "CITATION NUMBER:",
    "type" : "Text",
    "max_length" : 0
},
{
    "name" : "TR-205[0].Page1[0].P1Caption[0].CaseNumber[0].CaseNumber[0]",
    "label" : "CASE NUMBER:",
    "type" : "Text",
    "max_length" : 0
} Thus, we discovered that the quality of form filling heavily depends on the internal structure of the input PDF form. How the form fields are stored directly impacts the final result. This remains one of the key challenges I still don’t have a complete solution for. Conclusion Let’s summarize. In this article, we explored how AI can automate filling PDF forms, using the IRS W-9 and TR-205 as examples. The core idea was to demonstrate how manual labor and errors can be reduced by automating document processing. All materials used in this article, including the original Python code, are available on GitHub. GitHub Feel free to leave comments, share your thoughts, or discuss your own experiences. If you have questions or want to explore any aspects of this article further, reach out to me!

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Evidence

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Never Fill Out a PDF Form Again With This Clever Script

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps