DEV Community: Smarteyeapps.com

Build a Free Online Email Extractor with JavaScript

Smarteyeapps.com — Tue, 18 Aug 2026 02:31:29 +0000

Finding email addresses inside a large block of text sounds simple—until you have to manually search through hundreds or thousands of lines.

That's why I built Online Email Extractor Free, a small browser-based tool that extracts email addresses from text, removes duplicates, and lets users copy, send, or download the results as CSV.

The goal was simple:

Paste text → Extract emails → Use the results
What the tool does
The tool accepts unstructured text such as:
Meeting notes
Contact lists
Business information
Copied web content
Documents
Code or logs
Research notes
After clicking Extract Emails, the application identifies email addresses and displays them in a clean grid.
For example, given:
Meeting Notes - Q3 Strategy Alignment

John from marketing (john.doe@example.com) presented
the new campaign.

Please contact his assistant at
sarah.smith123@company.co.uk.

Send the API documentation to
admin@dev-ops.tech.

CC accounting at support@billing.net.
The extractor produces:
john.doe@example.com
sarah.smith123@company.co.uk
admin@dev-ops.tech
support@billing.net
Duplicate addresses are removed automatically.
Why build it entirely in the browser?
One of the main decisions was to make the extraction process client-side.
There is no reason to upload a user's text to a server just to find email addresses.

The basic architecture is:

User Input
↓
Browser JavaScript
↓
Find Email Addresses
↓
Normalize & Deduplicate
↓
Display Results

This provides two important benefits:

Privacy
The user's pasted content can remain on their device.
Speed
There is no API request required for the extraction itself.
For a small utility like this, browser-based processing is a good fit.
Extracting Email Addresses with JavaScript
The core of the application can be implemented with a regular expression.
A simple implementation looks like this:
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}/g;

const emails = text.match(emailRegex) || [];
This searches the supplied text for strings that resemble email addresses.
For example:
const text = Contact john@example.com or sales@example.com. You can also reach john@example.com.;

const matches = text.match(emailRegex) || [];

console.log(matches);
The result contains:
[
"john@example.com",
"sales@example.com",
"john@example.com"
]
But we don't want duplicate results.
Removing Duplicate Email Addresses
JavaScript's Set makes deduplication straightforward:
const uniqueEmails = [...new Set(matches)];
Now the result becomes:
[
"john@example.com",
"sales@example.com"
]
I also normalize the values before deduplication:
const uniqueEmails = [
...new Set(
matches.map(email => email.trim().toLowerCase())
)
];
This prevents variations such as:
John@example.com
john@example.com
JOHN@example.com
from appearing as separate results.
Displaying the Results
The extracted addresses can then be rendered as a simple grid.
Each result provides useful actions:
┌──────────────────────────────────────────┐
│ john@example.com Send Copy │
└──────────────────────────────────────────┘
The interface is intentionally simple.
Users don't need to understand how the extraction works. They just need to get their email addresses quickly.
Copying an Individual Email
The Clipboard API makes individual copying easy:
async function copyEmail(email) {
await navigator.clipboard.writeText(email);
}
For example:

Copy

For copying all extracted addresses:
async function copyAllEmails(emails) {
await navigator.clipboard.writeText(
emails.join('\n')
);
}
The user can then paste the list into another application.
Sending an Email
Another small but useful feature is the Send button.
Instead of implementing an email delivery system, the application can use the user's default email client:
function sendEmail(email) {
window.location.href = mailto:${email};
}
This keeps the feature lightweight.
The extractor doesn't need:
SMTP configuration
Email provider integration
User accounts
Email infrastructure
It simply hands the address to the user's email client.
Downloading the Results as CSV
The extracted emails can also be exported directly from the browser.
For example:
function downloadCSV(emails) {
const csv = [
'Email',
...emails
].join('\n');

const blob = new Blob([csv], {
    type: 'text/csv;charset=utf-8;'
});

const url = URL.createObjectURL(blob);

const link = document.createElement('a');
link.href = url;
link.download = 'extracted-emails.csv';

document.body.appendChild(link);
link.click();
link.remove();

URL.revokeObjectURL(url);

}
This creates the CSV locally without requiring a backend export endpoint.
Keeping the Interface Simple
The biggest challenge with utility tools isn't necessarily the JavaScript.
It's the UI.
For this type of application, the workflow should be obvious immediately:
┌─────────────────────────────────────────────┐
│ │
│ Paste your text here... │
│ │
│ │
└─────────────────────────────────────────────┘

                [ Extract Emails ]

Extracted Emails (9)

┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐
│ john@example.com │ │ sales@example.com │ │ info@example.com │
│ Send Copy│ │ Send Copy│ │ Send Copy│
└────────────────────┘ └────────────────────┘ └────────────────────┘

[ Copy All Emails ] [ Download as CSV ]

There shouldn't be unnecessary steps between the user and the result.

Why I Made It Free
This is part of a broader idea behind Smarteyeapps.
Instead of building only large SaaS applications, we're experimenting with small, focused web applications that solve one specific problem.
The email extractor is a good example:
One problem. One tool. No complicated setup.
The tool is free to use, with no registration required.
Security and Privacy
Because the extraction can happen entirely in the browser, sensitive text doesn't need to be sent to an application server.
The architecture can therefore be:
┌─────────────────┐
│ Browser │
│ │
Input ─────────►│ Email Extractor │
│ JavaScript │
│ │
└─────────────────┘
│
▼
Extracted Emails
There is no server-side processing required for the core extraction functionality.
Of course, if you add analytics, logging, authentication, or other external services, those should be evaluated separately from the extraction process.
A Small Tool Can Still Be Useful
One thing I like about building micro-apps is that the application doesn't need dozens of features to be useful.

The entire workflow can be summarized in three steps:

Paste Paste text containing email addresses.
Extract Find email addresses and remove duplicates.
Use Copy, send, or download the results. That's it. Try the Tool I've made the Online Email Extractor Free available as a free browser-based utility. Extract email addresses from text without manually searching through the content. 👉 https://smarteyeapps.com/email-extractor If you build similar browser-based utilities, I'd be interested in hearing what approaches you use for client-side text processing.

I Built a Free QR Menu SaaS with Laravel 12 & React — Here's What I Learned

Smarteyeapps.com — Tue, 28 Jul 2026 16:11:32 +0000

A few weeks ago, I challenged myself to build another micro SaaS.
Instead of creating another AI-powered tool, I wanted to solve a simple, real-world problem.
Restaurant owners still spend time and money printing menus every time prices change or new dishes are added.
The solution seemed straightforward: build a QR Menu Builder that lets restaurants manage their menu online and generate a QR code for customers.
The idea was simple.
Building it wasn't.
In this article, I'll share some of the architectural decisions, challenges, and lessons I learned while building it with Laravel 12, React, Inertia.js, and Tailwind CSS.
The Tech Stack
I wanted a stack that I already trusted.

Backend

Laravel 12
PHP 8.4
MySQL

Frontend

React
Inertia.js
Tailwind CSS
Vite

Laravel remains my first choice because it allows me to move quickly without sacrificing code organization.
React + Inertia gives me a modern SPA experience without maintaining separate frontend and backend applications.
For a solo developer building multiple micro SaaS products, this combination has been extremely productive.
Designing the Database
One mistake I've made in previous projects was coupling everything together.
This time I kept the database simple and modular.
restaurants
├── categories
│ └── menu_items
│
├── qr_codes
│
└── scans
The relationships are straightforward.
Restaurant

hasMany Categories

Stop Copying Phone Numbers One by One: Build a Simple WhatsApp Contact Extractor

Smarteyeapps.com — Fri, 24 Jul 2026 16:56:40 +0000

As a developer, I often find myself collecting contacts from business directories, PDFs, websites, and documents.
The workflow was always the same:
Copy a phone number
Save it as a contact (or copy it again)
Open WhatsApp
Send a message
Repeat...

After doing this hundreds of times, I decided to build a small tool to automate the repetitive part.
The Idea
The tool accepts any block of text and automatically extracts phone numbers.

Once extracted, each number can be used to:

💬 Open a WhatsApp chat
📞 Make a phone call
📩 Send an SMS
📥 Export contacts to CSV

No manual copy-paste for every contact.

Example Workflow
Copy text from a business directory, website, or PDF.
Paste it into the tool.
Click Extract Mobile Numbers.
Start messaging contacts immediately.
How It Works
The core logic is intentionally simple:
Parse plain text

Detect phone numbers using pattern matching
Remove duplicates
Normalize numbers
Generate action buttons for WhatsApp, Call, SMS, and CSV export
Everything runs directly in the browser, so there's nothing to install.

Remove duplicates

This isn't a complex SaaS or an AI-powered application.
It's a small utility that solves a real problem I faced almost every day.
Sometimes the simplest tools save the most time.

What's Next?

I'm planning to add:
Name detection
Duplicate contact merging
Better international phone number support
Contact grouping
Copy-to-clipboard improvements
I'd love to hear your feedback and ideas.

👉 Try Contact Grabber:
https://www.smarteyeapps.com/contact-grabber