Turn Messy Emails into Clean Data with AI (Claude on Bedrock)

Dave and the Spreadsheet of Eternal Sadness

Dave runs a successful consulting business. Every morning, he opens his inbox to find 10-15 new lead inquiries from his website’s contact form. This is good. What’s not good is the next hour of his life.

He opens an email. Reads it. Finds the name. Copies it. Pastes it into a spreadsheet. Finds the phone number. Copies it. Pastes it. Finds their requested service. Tries to decipher what they actually mean. Pastes it. He does this over and over, every single day. His high-value, strategic consulting brain is being used as a glorified copy-paste machine. It’s soul-crushing, error-prone, and a complete waste of his talent. He calls it the “Spreadsheet of Eternal Sadness.”

Today, we’re going to fire Dave from his data entry job so he can focus on being the CEO. We’re going to build him a tireless, perfectly accurate robot intern that reads those messy emails and turns them into clean, structured data that a computer can actually understand and act upon. No more spreadsheets. No more sadness.

Why This Matters

This isn’t just about saving an hour a day. This is a foundational building block for serious automation. Businesses run on data, but most of that data arrives in a messy, unstructured format like emails, PDFs, or support tickets.

It Kills Human Error: Manual data entry is a recipe for typos, missed fields, and disaster. An AI extractor does it perfectly every time.
It Enables Speed: A lead that’s processed instantly and gets an automated follow-up is 10x more likely to close than one that waits hours for Dave to finish his coffee and spreadsheet chores.
It Creates Scalability: You can process 10,000 emails as easily as you process 10. Your growth is no longer limited by how fast your team can type.

This workflow transforms your messiest data intake point into a clean, predictable pipeline. It’s the difference between a cluttered workshop and an automated assembly line.

What This Tool / Workflow Actually Is

We’re using two main components:

1. Unstructured Text: Think of this as any block of human-written text. An email from a customer, a review on your website, a legal contract, a resume. It has all the information you need, but it’s not organized for a computer.

2. A Large Language Model (LLM) as an Extractor: We will use Anthropic’s Claude 3 Sonnet model. We’re not asking it to write a poem or a blog post. We’re giving it a very specific, boring job: read this text and pull out the exact pieces of information I want, then format it as JSON. JSON (JavaScript Object Notation) is just a clean, key-value format that every application on earth can understand.

We’ll be accessing Claude via Amazon Bedrock, which is AWS’s platform for using various AI models. Think of Bedrock as a universal remote for AI—it lets you use models from different companies through one consistent, reliable API.

This workflow does NOT replace your CRM or your database. It’s the critical first step that *feeds* those systems with clean, reliable data.

Prerequisites

This involves a tiny bit of setup, but trust me, the payoff is massive. We are building industrial-grade infrastructure here, not a toy.

An AWS Account: If you don’t have one, head to aws.amazon.com. It’s the backbone of the internet; you should have an account anyway.
Model Access in Amazon Bedrock: Inside your AWS console, go to the Bedrock service. In the bottom-left menu, find “Model access” and make sure you request access to “Anthropic / Claude 3 Sonnet”. It’s usually approved instantly.
Python 3 and Boto3: Boto3 is the official AWS toolkit for Python. If you don’t have it, open your terminal and run: pip install boto3.
AWS Credentials Configured: You need to securely tell your computer how to access your AWS account. The best way is the AWS CLI. Search for “install AWS CLI” and follow the 2-minute setup. You’ll run aws configure and paste in the access keys you create in the IAM section of AWS.

I know this sounds like a lot, but it’s a one-time setup that unlocks the ability to build basically any AI automation you can dream of. You got this.

Step-by-Step Tutorial

Let’s build Dave’s robot intern. Our goal is to take a raw email string and turn it into a perfect JSON object.

Step 1: The Raw Material (The Messy Email)

First, let’s define our input. This is the kind of email Dave gets all day long. Notice how the information is all there, but it’s a mess. Sometimes there’s a phone number, sometimes not. The formatting is inconsistent.

email_body = """
Hi there,

My name is Sarah Connor and I'm interested in your 'System Automation' package. 
My budget is around $5,000.

You can reach me at sarah.c@sky.net or call me at 555-123-4567.

Thanks,
Sarah
"""

Step 2: The Magic Wand (The Prompt)

This is the most important part. We need to write clear instructions for the AI. We’ll tell it its role, what to do, and *exactly* what format to use for the output. This is called prompt engineering.

prompt = f"""
You are a data extraction expert. Your job is to read the following email and extract the key information into a structured JSON object.

The JSON object must have these exact keys: "name", "email", "phone", "service_interest", "budget".

- If a piece of information is missing, the value for that key should be null.
- For the 'budget', extract only the numerical value.
- Do not include any explanation or commentary. Only output the raw JSON object.

Here is the email:


{email_body}

"""

See how specific that is? We gave it the keys, told it how to handle missing data, and even how to format the budget. This reduces errors and ensures we always get predictable output.

Step 3: The Python Code (The Factory)

Now, let’s write the Python script that sends this job to Amazon Bedrock. Create a file named extract_data.py.

import boto3
import json

# --- 1. DEFINE OUR INPUTS ---

# The messy email we want to process
email_body = """
Hi there,

My name is Sarah Connor and I'm interested in your 'System Automation' package. 
My budget is around $5,000.

You can reach me at sarah.c@sky.net or call me at 555-123-4567.

Thanks,
Sarah
"""

# The powerful prompt that tells the AI what to do
prompt = f"""
You are a data extraction expert. Your job is to read the following email and extract the key information into a structured JSON object.
The JSON object must have these exact keys: "name", "email", "phone", "service_interest", "budget".
- If a piece of information is missing, the value for that key should be null.
- For the 'budget', extract only the numerical value.
- Do not include any explanation or commentary. Only output the raw JSON object.

Here is the email:


{email_body}

"""

# --- 2. SETUP THE BEDROCK CLIENT ---

# Create a client to interact with the Bedrock service
bedrock_runtime = boto3.client(service_name='bedrock-runtime', region_name='us-east-1')

# --- 3. PREPARE THE API REQUEST BODY ---

# This is the specific format that Claude 3 expects
body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": prompt
        }
    ]
})

# --- 4. CALL THE MODEL AND GET THE RESPONSE ---

response = bedrock_runtime.invoke_model(
    body=body,
    modelId='anthropic.claude-3-sonnet-20240229-v1:0', 
    accept='application/json',
    contentType='application/json'
)

# --- 5. PARSE AND PRINT THE CLEAN DATA ---

# The response body is a streaming object, so we need to read and parse it
response_body = json.loads(response.get('body').read())

# The actual extracted text is in the 'content' field
extracted_text = response_body['content'][0]['text']

# Print the final, clean JSON data
print("--- Extracted JSON Data ---")
print(extracted_text)

# You can now load this string as a proper Python dictionary
# clean_data = json.loads(extracted_text)
# print(f"\
Lead Name: {clean_data['name']}")

Complete Automation Example

Save the extract_data.py file. Open your terminal in the same folder and run it:

python extract_data.py

The output should be fast, clean, and perfect:

--- Extracted JSON Data ---
{
    "name": "Sarah Connor",
    "email": "sarah.c@sky.net",
    "phone": "555-123-4567",
    "service_interest": "System Automation",
    "budget": 5000
}

That’s it! You just turned a messy block of text into a beautiful, structured object that can be used in a thousand different ways. Now try changing the email_body variable. Remove the phone number. Change the service. The script will handle it perfectly every time. Dave is now free.

Real Business Use Cases

This extraction pattern is a superpower. Here are five ways to use this exact same code:

Invoice Processing: Feed an email with a PDF invoice attached (after converting the PDF to text). Extract `invoice_number`, `due_date`, `total_amount`, and `vendor_name` to automate your accounts payable.
Real Estate Lead Routing: Parse emails from Zillow or your website to extract `property_address`, `buyer_or_seller`, `price_range`, and `timeline`. Route hot leads to your top agent instantly.
Customer Feedback Analysis: Process support tickets or survey responses to extract `sentiment` (positive/negative), `product_mentioned`, and `key_issue`. Aggregate this data to spot trends.
Recruiting and HR: Feed a candidate’s resume (as text) into the extractor. Pull out `years_of_experience`, `key_skills`, `previous_company`, and `education_level` to quickly screen applicants.
Legal Document Review: Extract key clauses, dates, and party names from contracts. For example, find the `contract_start_date`, `renewal_terms`, and `liability_cap` from a hundred different vendor agreements.

Common Mistakes & Gotchas

Lazy Prompting: If you just say “Extract info from this email,” you’ll get inconsistent results. Be ruthlessly specific in your prompt. Give it the exact keys. Tell it how to handle edge cases. This is 90% of the battle.
Not Asking for JSON: Always explicitly tell the model to output a JSON object. This forces it into a structured format that your code can easily parse. Trying to parse a natural language sentence is much harder and more brittle.
Using the Wrong Model: For extraction, you want a fast, smart, and reliable model like Claude 3 Sonnet. Using a smaller, dumber model might miss details. Using a giant, super-creative model might be overkill and slower.
Ignoring Missing Data: Your prompt *must* tell the model what to do if a field isn’t in the source text (e.g., `”phone”: null`). If you don’t, the model might just omit the key, which will break your code when it tries to access it.

How This Fits Into a Bigger Automation System

This script is the front door of a much larger automation factory. On its own, it just prints to the screen. But when you connect it:

From an Email Server: You can use a tool like Zapier or Make.com, or a service like Amazon SES, to trigger this Python script every time a new email arrives in a specific inbox.
To a CRM: Once you have the clean JSON, you can make an API call to your CRM (HubSpot, Salesforce, etc.) to create a new contact and a new deal, with all the fields perfectly populated. The lead is in your system before a human ever sees it.
To a Database: You could pipe the JSON directly into a database like Airtable or a PostgreSQL table to build a dashboard, run analytics, or create a searchable archive of all incoming requests.
To a Triage Agent: Remember our last lesson? You could combine them! First, use a router agent to classify the email’s intent. If the intent is “New Lead,” *then* trigger this extractor agent to get the details.

What to Learn Next

You’ve successfully built an AI that can read and understand. You’ve turned unstructured chaos into structured order. This is a massive step.

But what good is clean data if it just sits there? The next logical step is to make our system *act* on this data.

In the next lesson of the course, we’re going to take the JSON object we just created and build the next stage of the assembly line. We’ll write a script that automatically adds the lead to a CRM, assigns it to a salesperson, and sends a personalized confirmation email back to the customer—all within seconds of the original inquiry.

We’ve built the data refinery. Next, we build the distribution network.

“,
“seo_tags”: “ai data extraction, amazon bedrock, claude 3, python, unstructured data, email parsing, business automation, json, lead automation”,
“suggested_category”: “AI Automation Courses