DEV Community: Satori Henry

Import a WhatsApp Group CSV into SQLite Without Losing the + Sign

Satori Henry — Wed, 11 Nov 2026 02:53:56 +0000

A phone number like +12025550148 looks numeric enough for a CSV importer to treat it as an integer. That works until you need the + back. The same problem turns 07700900123 into 7700900123, and the database no longer knows how many zeros were at the start.

Here's a small local import that keeps those values intact. It uses Python's standard library and an in-memory SQLite database, so you can run it without installing a package or setting up a database server.

Reproduce the problem with two rows

Run this in a fresh SQLite session.

CREATE TABLE example (phone NUMERIC);
INSERT INTO example VALUES ('+12025550148'), ('07700900123');

SELECT phone, typeof(phone) FROM example ORDER BY rowid;

Stored value	Storage type
`12025550148`	`integer`
`7700900123`	`integer`

The quotes in the INSERT make the inputs strings, but SQLite's NUMERIC affinity still converts them to integers. To preserve the original representation, keep the values as strings in Python and use a TEXT column in SQLite.

Import the CSV as text

Save this example as members.csv. It uses fictional data and two columns from a group CSV exported by WAExport, a Chrome extension we build for WhatsApp Web. The extension can export member numbers from selected groups and include the source group for each row. whatsapp group number extractor

Phone Number,Group Name
+12025550148,"Launch, US"
07700900123,QA Sandbox
+12025550148,Beta Testers

Save the following as inspect_members.py in the same folder. The importer accepts extra columns and reads UTF-8 CSV files with or without a byte order mark.

import csv
import sqlite3
from contextlib import closing

with closing(sqlite3.connect(":memory:")) as db:
    db.execute("""
        CREATE TABLE group_members (
            phone TEXT NOT NULL,
            source_group TEXT NOT NULL
        )
    """)

    with open("members.csv", encoding="utf-8-sig", newline="") as source:
        reader = csv.DictReader(source)
        required = {"Phone Number", "Group Name"}
        if not required.issubset(reader.fieldnames or []):
            raise SystemExit("CSV must contain Phone Number and Group Name.")

        with db:
            for row in reader:
                phone = row["Phone Number"]
                group = row["Group Name"]
                if not phone or not group:
                    raise SystemExit(f"Missing value at CSV line {reader.line_num}.")

                db.execute(
                    "INSERT INTO group_members (phone, source_group) VALUES (?, ?)",
                    (phone, group),
                )

    for phone, group, storage_type in db.execute("""
        SELECT phone, source_group, typeof(phone)
        FROM group_members
        ORDER BY rowid
    """):
        print(f"{phone} | {group} | {storage_type}")

Run python inspect_members.py. You should see three rows.

+12025550148 | Launch, US | text
07700900123 | QA Sandbox | text
+12025550148 | Beta Testers | text

csv.DictReader keeps the phone field as a string and handles the comma inside the quoted group name. SQL placeholders pass each field as a value, and typeof(phone) confirms the storage type. The repeated number still appears twice because it belongs to two source groups.

The import preserves the phone field exactly as it appears in the CSV. If you later need to match numbers from different sources, keep this raw column and derive a separate normalized value using the country information available to you. Once an earlier spreadsheet or import has stripped a leading zero, this script can't recover it from the altered file.

Disclosure: ChatGPT drafted this article and its code example. The example was run with the fictional CSV shown above.

Architecture Decoded: How to Build a Complete Browser Extension-Based WhatsApp Bulk Sending Engine

Satori Henry — Mon, 17 Aug 2026 11:05:09 +0000

When building WhatsApp automation tools, the technology stack often determines the product's stability and the user's risk of getting banned. Compared to headless browser solutions like Puppeteer, operating directly within the DOM of the WhatsApp Web runtime via a Chrome Browser Extension is currently the more mainstream and secure technical path.

This article will deconstruct, from a purely technical perspective, how to implement a bulk sending engine equipped with frontend interaction, task scheduling, and state validation.

Core Architecture Design (Manifest V3) The underlying architecture of the entire sending engine is based on the Chrome Manifest V3 standard, primarily consisting of the following core modules working in synergy:

Background Service Worker: Responsible for global state management, API communication, and coordinating different page tabs. Due to the lifecycle limits of V3, it requires designing a keep-alive mechanism or persisting state into chrome.storage.

Content Scripts: Injected directly into the context of web.whatsapp.com. Responsible for reading page elements, hijacking native input events, and rendering dashboard components onto the user interface.

Popup UI: The frontend interface used for hosting user uploads of Excel / CSV files, configuring dynamic variables, and setting sending intervals.

Key Technical Implementation Modules 2.1 Task Queue & State Management The core of bulk sending is a highly available asynchronous task queue. You cannot simply use a synchronous for loop, as this will block the main thread and easily trigger WhatsApp's anti-automation detection mechanisms.

The engine needs to maintain a state machine to record the progress of the current task (waiting, sending, success, failed). By wrapping setTimeout and combining it with async/await, you can implement randomized sending intervals (e.g., 10 to 15 seconds) to mimic the operational rhythm of a real human user.

2.2 DOM Manipulation & Event Dispatching
WhatsApp Web is built on React, and its DOM structure uses a massive amount of dynamically obfuscated class names. We need to locate key elements using stable attributes (such as title or data-icon).

Implementing the sending action typically involves the following low-level steps:

Establish a Chat Channel: Force open the dialog box of the target number via the URL scheme https://web.whatsapp.com/send?phone=xxx.

Locate the Input Box: Find the message input div (which usually carries the contenteditable="true" attribute).

Simulate Input: You cannot directly modify innerHTML or value, as this will not trigger React's underlying state updates. You must create a native InputEvent or TextEvent and dispatch it to the input box node using dispatchEvent to force React to bind the data.

Trigger Send: Locate the DOM node for the send button and dispatch a MouseEvent('click') to simulate a real user click.

2.3 Pre-send Number Verification & Filtering Module
Before pushing numbers into the sending queue, the system needs to sanitize the targets. To ensure client-side processing speed and keep the overall system lightweight, the number detection logic here should be simplified.

In terms of technical implementation, there is no need for deep carrier network penetration checks or complex protocol-level WhatsApp authentication. The engine simply needs to capture the native error prompt layer returned by WhatsApp Web (such as the "Phone number shared via url is invalid" popup) when attempting to establish the chat DOM structure. It can then output a simple Valid or Invalid status identifier directly in the logs. This minimalist validation logic significantly reduces API dependencies and memory consumption.

2.4 Dashboard Interaction & Subscription Flow
A commercial-grade SaaS engine must not only handle underlying logic but also possess a comprehensive UI feedback mechanism. When the Content Script is injected into the page, an independent DOM tree must be built to render real-time data of the sending progress as a floating sidebar.

Meanwhile, every time a bulk sending task is triggered, an asynchronous authentication middleware layer needs to be inserted:

Quota Validation: Call the server-side API to verify the current account's subscription tier.

Frontend Interception: If the system detects that the user has exceeded their daily sending quota, the state machine must immediately suspend the current sending queue and render a preset Upgrade Popup Box directly in the center of the page via DOM injection.

Checkout Flow: The popup embeds interactive logic to guide the user through a plan upgrade. Upon a successful payment callback, the Service Worker's authentication state is updated via WebSockets or polling, after which the engine automatically resumes and continues executing the suspended sending queue.

Exception Handling & Defensive Programming In engineering implementation, the biggest technical challenges stem from the asynchronous loading nature of frontend frameworks and network fluctuations:

React Rendering Latency: When loading a chat window, DOM rendering is entirely asynchronous. The engine must implement a mechanism based on MutationObserver or polling with a timeout limit. This ensures the target node is fully rendered and in an interactive state before executing the next input operation, preventing the program from throwing Element Not Found exceptions.

Resource Reclamation: When bulk sending a large volume of rich media messages containing images, page memory can spike sharply, easily leading to browser crashes. After each round of message sending, the engine must actively clean up and destroy any injected temporary DOM nodes and redundant object references.

Conclusion Building a complete whatspp bulk sender from scratch is far more than just writing a few lines of auto-click scripts. It requires developers to perfectly integrate frontend DOM reverse engineering, granular asynchronous queue scheduling, lightweight state validation, and seamless subscription checkout interaction logic into the lifecycle of a single browser extension.