Email parser HubSpot integration for contacts and deals

A HubSpot email parser workflow starts where your marketing team receives the lead. A directory, marketplace, referral partner or external quote form sends a notification. Forward that message to a ParsedMail inbox and define a typed schema for the contact and inquiry. ParsedMail reads the notification without extraction templates and posts the result to your webhook. The lead email parsing guide covers choosing fields across sources.

The JSON event contains id, type, created and data. For email.parsed, the email object is data, extracted fields are data.data.*, and the email ID is data.id. Use data.confidence_avg and data.needs_review for checks before writing. Your automation maps those fields to HubSpot properties and creates or updates the contact.

HubSpot forms capture submissions from forms on your site. They are useful when you control the form, but a partner referral or marketplace notification may arrive from a tool whose form you cannot replace. The lead details then live in an email body instead of a HubSpot submission.

Logging emails through a BCC or forwarding address, or a connected inbox, can attach email activity to CRM records. Depending on the logging route and settings, contact creation may also occur. That does not extract the prospect name, phone, company and request from a notification body into separate contact properties. The notification sender may be the directory rather than the prospect.

To parse emails into HubSpot contacts, extract the prospect details first and match on that person's email. This keeps the lead identity separate from the service sending the notification. Teams comparing CRM destinations can also use the Salesforce integration guide.

These are example schema keys you configure. Missing values remain null, so omit them from updates to avoid clearing useful CRM data. HubSpot internal property names are lowercase. Use internal option values for dropdown properties rather than their display labels.

Keep lifecycle and lead status under your sales operations rules. Do not reset an existing customer's lifecycle stage merely because another inquiry arrived. Mark email required in ParsedMail and check it in the receiver before creating a contact.

Quote requests and order notifications may need a deal as well as a contact. Create or update the contact first and retain the returned contact ID. Then create a deal with dealname, an amount when supplied, and the internal IDs for pipeline and dealstage. Associate the deal with that contact so the request appears in the correct sales context.

If your schema has a money field called budget, map data.data.budget.amount to the deal amount. Keep currency handling consistent with your HubSpot configuration. Choose the pipeline and stage from your own process rather than interpreting arbitrary email wording as an internal stage ID.

Updating a contact by email does not deduplicate deals. Track whether the inquiry already produced a deal, using the ParsedMail email ID or a supplied order or request reference. Test a repeated delivery before enabling automatic deal creation.

Create a Zap with Webhooks by Zapier and Catch Hook. Webhooks by Zapier is a premium app, so check your Zapier plan. Paste the hook URL into a ParsedMail webhook endpoint and forward a real lead notification. The Zapier integration guide explains the trigger and field labels.

Filter for type equal to email.parsed, data.needs_review false and a present prospect email. Skip webhook.test events. Add HubSpot Create or Update Contact, mapping data.data.email, shown as Data Data Email, to email. Map the remaining contact properties and store data.id in a custom property named parsedmail_email_id.

Add Create Deal only when the notification represents a sales opportunity, and associate it with the contact. Catch Hook does not verify signatures automatically. For verification inside Zapier, use Catch Raw Hook and a code step with the original body and headers before CRM actions.

In Make, start with Webhooks and Custom webhook. Register its URL in ParsedMail and capture a real notification. Open data, then data again to reach contact fields. Filter on event type, review status and email before the HubSpot CRM modules. Use Create or Update a Contact, then optionally create and associate a deal. The Make integration guide covers capturing the bundle.

In n8n, receive POST requests with a Webhook node. The address is body.data.data.email, review status is body.data.needs_review, and the email ID is body.data.id. Add an If node with the same checks, then the HubSpot node with the Create or Update contact operation. Activate the workflow and register its production URL after testing. Follow the n8n integration guide for signature verification using the raw body.

Your receiver can update by email with PATCH /crm/v3/objects/contacts/{email}?idProperty=email. This returns 404 when the contact is missing, so fall back to POST /crm/v3/objects/contacts. This Python requests worker runs after verification and durable event storage. Supply your own private app access token with contact read and write scopes, and create parsedmail_email_id first.

from urllib.parse import quote
import requests

def save_contact(event, access_token):
    if event.get("type") not in ("email.parsed",):
        return
    email = event["data"]
    fields = email["data"]
    if email["needs_review"] or not fields.get("email"):
        return
    properties = {"parsedmail_email_id": email["id"]}
    for source, target in {
        "email": "email", "first_name": "firstname",
        "last_name": "lastname", "phone": "phone",
        "company": "company", "job_title": "jobtitle",
    }.items():
        if fields.get(source) is not None:
            properties[target] = fields[source]
    url = "https://api.hubapi.com/crm/v3/objects/contacts"
    headers = {"Authorization": "Bearer " + access_token}
    response = requests.patch(
        url + "/" + quote(fields["email"], safe=""),
        params={"idProperty": "email"}, headers=headers,
        json={"properties": properties}, timeout=10,
    )
    if response.status_code == 404:
        response = requests.post(
            url, headers=headers,
            json={"properties": properties}, timeout=10,
        )
    response.raise_for_status()
    return response.json()["id"]

For batch upsert, use POST /crm/v3/objects/contacts/batch/upsert with {"inputs": [{"id": email, "idProperty": "email", "properties": {...}}]}, substituting the prospect email and properties. PATCH followed by POST is not atomic. Handle a concurrent creation conflict by retrying the email update, and persist worker failures for retry.

Before queueing, verify ParsedMail-Signature as HMAC-SHA256 over the timestamp, a dot and the raw body, using the endpoint secret. Compare in constant time and reject timestamps more than 300 seconds from your clock. Follow the webhook signature and delivery documentation. Return 2xx after durable storage and handle API failures in the worker.

Email is HubSpot's dedupe key for contacts in this workflow. Match on the extracted prospect email across notifications. ParsedMail separately suppresses duplicate emails in the same inbox over 30 days using Message-ID, or sender, subject and body when Message-ID is absent. Those duplicates are not parsed or sent again.

If a receiver does not answer 2xx within 15 seconds, retries follow after 1 minute, 5 minutes, 30 minutes, 2 hours and 12 hours, measured after successive failures. Store the unchanged Idempotency-Key with a unique constraint to control repeat processing. Save data.id as parsedmail_email_id for tracing the latest inquiry on a contact. Keep a separate processed-event record, especially for deals.

On Growth and Scale, human review before delivery holds uncertain emails or missing required fields until approval, then sends corrected values. Rejected emails are not sent. Starter has confidence scores without the queue, so route uncertain results to a person in your automation.

For example, 600 lead emails a month fit Starter's 1,000 email monthly allowance. Starter costs $49 per month, or $24 per month billed yearly, and includes 300 attachment pages per month and webhooks. Choose Growth if you need review before CRM delivery, even when your volume fits Starter.

Growth costs $149 per month, or $74 per month billed yearly, with 5,000 emails per month, the review queue and 5 seats. Scale costs $499 per month, or $249 per month billed yearly, with 25,000 emails per month and review. Compare the ParsedMail pricing and plan allowances.

HubSpot API access through private apps is available on all HubSpot accounts, including free accounts. Workflows acting on the resulting contacts may require paid hubs. Budget separately for your automation tool or hosting, and check its complete contact and deal flow. ParsedMail webhook retries do not consume extra parsed email allowance.