This article provides a complete, practical walkthrough of the Manual Extractfromfile Send Webhook n8n agent. It connects HTTP Request, Webhook across approximately 1 node(s). Expect a Intermediate setup in 15-45 minutes. One‑time purchase: €29.

What This Agent Does

This agent orchestrates a reliable automation between HTTP Request, Webhook, handling triggers, data enrichment, and delivery with guardrails for errors and rate limits.

It streamlines multi‑step processes that would otherwise require manual exports, spreadsheet cleanup, and repeated API requests. By centralizing logic in n8n, it reduces context switching, lowers error rates, and ensures consistent results across teams.

Typical outcomes include faster lead handoffs, automated notifications, accurate data synchronization, and better visibility via execution logs and optional Slack/Email alerts.

How It Works

The workflow uses standard n8n building blocks like Webhook or Schedule triggers, HTTP Request for API calls, and control nodes (IF, Merge, Set) to validate inputs, branch on conditions, and format outputs. Retries and timeouts improve resilience, while credentials keep secrets safe.

Third‑Party Integrations

• HTTP Request
• Webhook

Import and Use in n8n

1. Open n8n and create a new workflow or collection.
2. Choose Import from File or Paste JSON.
3. Paste the JSON below, then click Import.
4. Show n8n JSON

   Title:  
   How to Send an HTML Email with an Embedded Image Using n8n and Gmail
   
   Meta Description:  
   Learn to automate HTML email creation and delivery with an embedded image using n8n and Gmail API. This step-by-step guide explains how each node works, from fetching the image to converting and embedding it.
   
   Keywords:  
   n8n email automation, Gmail API n8n, embed image in email, HTML email with image, send email with n8n, n8n Gmail integration, base64 image in email, automated email n8n
   
   Third-Party APIs Used:
   
   - Gmail API (via https://www.googleapis.com/gmail/v1/users/me/messages/send)
   - Public image URL (https://thistleandrose.co.uk/img/userimages/Page/0/bgmainfront.jpg)
   
   —
   
   Article:
   
   Automating HTML Emails with Embedded Images Using n8n and Gmail
   
   Sending beautifully styled HTML emails complete with inline images is a common requirement in modern communication workflows, especially for marketing, customer updates, and transactional messages. n8n, a powerful open-source automation tool, makes this surprisingly easy—no coding required. In this article, we’ll walk through how to create a simple n8n workflow to send an HTML email with an embedded image via Gmail.
   
   By the end of this tutorial, you’ll understand how to:
   
   - Configure email metadata (like sender, recipient, subject)
   - Embed a base64-encoded image inline in the email body
   - Use Gmail’s API to send the final message
   
   Let’s break down the process node by node.
   
   Step 1: Manual Trigger
   
   Node: 🟢 When clicking "Test workflow"
   
   This node allows you to manually test the workflow start-to-finish. It’s particularly useful for building and verifying automations step-by-step without needing scheduled or live event triggers.
   
   Step 2: Set Up Message Metadata
   
   Node: 🟢 Message settings
   
   Here, we define:
   
   - From: sender@example.com
   - To: recipient@example.com
   - Subject: “Email with embedded image”
   - Body: HTML content containing the embedded image reference:
   
   <p>This email contains an embedded image:</p>
   <p><img src='cid:image1'></p>
   
   The image is referenced using Content-ID (CID), a common technique for embedding images directly in emails rather than linking externally.
   
   📝 Sticky Note Tip:
   “To use the image in the body of the email, insert `<img src='cid:image1'>`”
   
   Step 3: Retrieve the Image
   
   Node: 🟢 Get image
   
   This HTTP node fetches an image from a public URL (https://thistleandrose.co.uk/img/userimages/Page/0/bgmainfront.jpg). This image will later be encoded in Base64 and embedded in the email body.
   
   📝 Sticky Note Tip:
   “Gets a random image from the internet. Replace this with your own image (should be called 'data')”
   
   Step 4: Convert Image to Base64
   
   Node: 🟢 Convert image to base64
   
   To embed the image inside the email, we must convert it into Base64 format. The Extract from File node takes care of this, transforming the binary representation of the image into a string version stored as chart1.
   
   Step 5: Compose the Raw MIME Message
   
   Node: 🟢 Compose message
   
   This is the heart of the workflow where all the previously defined pieces come together. Here, we create a raw MIME-formatted email string including headers, HTML content, and the embedded image. The email is declared as `multipart/related`, allowing text and image components to be packaged together.
   
   Important elements of this composition include:
   
   - Standard email headers (From, To, Subject, MIME type)
   - Email's HTML body referencing the embedded image via `cid:image1`
   - Image content, along with necessary headers like Content-Disposition and Content-ID set to `image1`
   
   Step 6: Send the Email via Gmail API
   
   Node: 🟢 Send message
   
   Instead of using n8n’s built-in Gmail node, this workflow demonstrates a more flexible approach using the Gmail API directly through an HTTP Request node. This allows us to send the MIME-structured raw email by base64-encoding the entire message and POSTing it to:
   
   https://www.googleapis.com/gmail/v1/users/me/messages/send
   
   Authentication is handled via a predefined Gmail OAuth2 credential set inside n8n. Be sure to add your own credentials here to execute the request successfully.
   
   📝 Sticky Note Tip:
   “We use an HTTP node rather than the Gmail node. Add your Gmail credentials here”
   
   📝 Final Setup Notes:
   
   Before running the workflow, ensure:
   
   - You’ve updated the sender and recipient fields in the "Message settings" node
   - You've configured the Gmail OAuth2 credentials in the “Send message” node
   - The image URL is replaceable; you can use any publicly accessible image
   
   Bonus Sticky Note for Testing:
   “Try me out
   1. Make sure you add your Gmail credential in the last node
   2. Update the sender and recipient in the 'Message settings' node
   3. Click 'test workflow'”
   
   Why Use This Workflow?
   
   This setup is ideal for anyone looking to automate personalized emails with embedded multimedia, ideal for:
   
   - Automatically generated reports or dashboards with inlined charts/screenshots
   - Marketing emails with branded visuals
   - Communicating internal updates with styled formatting
   
   Unlike attachments, embedded images provide a more seamless and polished user experience. And since Gmail only allows embedding images this way via the MIME raw message format, using n8n and the Gmail API is a perfect low-code solution.
   
   Conclusion
   
   You’ve now got a repeatable, customizable email-sending workflow using n8n that embeds images inline using just a few nodes. With the capability to extend this setup—perhaps by triggering it with a webhook, or dynamically generating HTML and image content—you can achieve advanced email automation tailored exactly to your needs.
   
   Happy automating!

5. Set credentials for each API node (keys, OAuth) in Credentials.
6. Run a test via Execute Workflow. Inspect Run Data, then adjust parameters.
7. Enable the workflow to run on schedule, webhook, or triggers as configured.

Tips: keep secrets in credentials, add retries and timeouts on HTTP nodes, implement error notifications, and paginate large API fetches.

Validation: use IF/Code nodes to sanitize inputs and guard against empty payloads.

Why Automate This with AI Agents

AI‑assisted automations offload repetitive, error‑prone tasks to a predictable workflow. Instead of manual copy‑paste and ad‑hoc scripts, your team gets a governed pipeline with versioned state, auditability, and observable runs.

n8n’s node graph makes data flow transparent while AI‑powered enrichment (classification, extraction, summarization) boosts throughput and consistency. Teams reclaim time, reduce operational costs, and standardize best practices without sacrificing flexibility.

Compared to one‑off integrations, an AI agent is easier to extend: swap APIs, add filters, or bolt on notifications without rewriting everything. You get reliability, control, and a faster path from idea to production.

Best Practices

• Credentials: restrict scopes and rotate tokens regularly.
• Resilience: configure retries, timeouts, and backoff for API nodes.
• Data Quality: validate inputs; normalize fields early to reduce downstream branching.
• Performance: batch records and paginate for large datasets.
• Observability: add failure alerts (Email/Slack) and persistent logs for auditing.
• Security: avoid sensitive data in logs; use environment variables and n8n credentials.

FAQs

Can I swap integrations later? Yes. Replace or add nodes and re‑map fields without rebuilding the whole flow.

How do I monitor failures? Use Execution logs and add notifications on the Error Trigger path.

Does it scale? Use queues, batching, and sub‑workflows to split responsibilities and control load.

Is my data safe? Keep secrets in Credentials, restrict token scopes, and review access logs.