Project Dashboard

100-Line RCS/SMS-Receive Farm

Total Lines

100

Est. Setup Cost (CAPEX)

£4,100

Est. Monthly Cost (OPEX)

£0

Project Overview

This project outlines the creation of a 100-line hybrid messaging gateway, leveraging existing infrastructure for networking and hosting. The system is designed to programmatically send RCS messages and receive both RCS and SMS. By using a "keep-alive" strategy for PAYG SIMs instead of monthly bundles, the operational costs are minimized to near zero, making this a highly cost-effective solution for large-scale, consent-based communication.

Cost Projection: CAPEX vs. 12-Month OPEX

This chart visualizes the initial setup investment against the minimal operational costs over the first year.

System Architecture

The farm is built on four key layers. This model assumes that the core networking gear (router, Wi-Fi) and the VPN server host are provided by existing infrastructure, allowing the project to focus on the essential components for messaging functionality.

Hardware

  • 100x Android Phones
  • Network Gear (Existing)
  • VPN Server Host (Existing)

Software

  • Android OS
  • Google Messages & Join
  • Miradore MDM (Free)
  • Open-Source VPN Client
  • Central Control Script

Networking

  • Isolated Wi-Fi (VLAN)
  • Self-Hosted VPN Service
  • IP Addresses (Existing)

SIMs

  • 100x PAYG SIM Cards
  • "Keep-Alive" Strategy

Operational Message Flow


graph TD
    subgraph Control Plane
        A[Central Script / App]
    end

    subgraph Farm Infrastructure
        B(Join API)
        C{Phone in Farm}
        D[Google Messages App]
        E[Join App on Phone]
    end

    subgraph External Network
        F[RCS/SMS Network]
        G[End User / Recipient]
    end

    A -- "1. Send Request" --> B
    B -- "2. Push Command" --> C
    C -- "3. Instructs" --> D
    D -- "4. Sends Message" --> F
    F -- "5. Delivers to" --> G
    
    G -- "6. User Replies" --> F
    F -- "7. Delivers to" --> C
    C -- "8. Message Received by" --> D
    D -- "9. Notifies" --> E
    E -- "10. Push Notification" --> B
    B -- "11. Webhook/Event" --> A
    A -- "12. Process Reply" --> A
    

Interactive Cost Breakdown

Use the slider below to adjust the number of phones in the farm and see how it impacts the estimated initial and monthly costs. This model excludes infrastructure costs (networking, server, IPs) which are assumed to be pre-existing.

Initial Setup Costs (CAPEX)

ItemCost
Android Phones£4,000
SIM Card Purchase£100
Total Setup£4,100

Monthly Running Costs (OPEX)

ItemCost
MDM Solution£0
Total Monthly£0

Provisioning Guide

This guide details the step-by-step process for provisioning each phone in the farm. While some steps require manual intervention, the use of an MDM solution like Miradore is critical for automating the bulk configuration and application deployment, making the setup of 100 devices manageable.

Operations & Risk Management

Successful long-term operation of the farm depends on a clear workflow for sending and receiving messages, as well as a robust strategy for managing legal, compliance, and technical risks. The following sections outline the critical considerations for maintaining a healthy and legitimate system.

Operational Workflow

  1. **Recipient Pre-Screening (CRITICAL):** Before sending, verify the target number is RCS-enabled to avoid failed messages.
  2. **Message Execution:** Use the Join API via your central script to send outgoing RCS messages.
  3. **SIM Keep-Alive:** Automate a single chargeable event (e.g., one SMS) every 5 months per SIM to prevent deactivation.
  4. **Monitoring:** Use the MDM dashboard to monitor device health and your VPN dashboard for network status.

Risk Management

  • **Legal Compliance:** Adhere strictly to UK's PECR and GDPR laws. Do not send unsolicited messages.
  • **Carrier Policy:** Be aware that using consumer SIMs for automated purposes violates most carrier policies. Low volume and human-like patterns are essential.
  • **SIM Deactivation:** The primary risk is carrier deactivation. The automated "Keep-Alive" mechanism is the primary defense.
  • **Redundancy:** Keep a stock of spare, activated SIM cards to quickly replace any blocked numbers.

Join API Example: Python Script

This Python script demonstrates how to send an RCS/SMS message using the Join API. It uses the `requests` library to make a simple web call to the Join endpoint. This is the fundamental building block for your central control application.

Prerequisites

  1. Find your **API Key** in the Join app on your phone (`Settings > Join API`).
  2. Find the **Device ID** of the phone you want to send from via the Join API web page.
  3. Install the `requests` library in Python: `pip install requests`.

send_message.py



import requests

# --- CONFIGURATION ---
# Replace with your actual Join API key
API_KEY = "YOUR_API_KEY_HERE" 
# Replace with the ID of the device you want to send from
DEVICE_ID = "YOUR_DEVICE_ID_HERE"
# The phone number you want to send the message to
RECIPIENT_NUMBER = "+447911123456" # Use international format
# The message you want to send
MESSAGE_TEXT = "Hello from my Python script! This is a test message sent via the Join API."

def send_join_message(api_key, device_id, number, text):
    """
    Sends an SMS/RCS message using the Join API.
    """
    print(f"Attempting to send message to {number}...")

    # Construct the API URL with all the required parameters
    api_url = (
        f"https://joinjoaomgcd.appspot.com/_ah/api/messaging/v1/sendPush"
        f"?apikey={api_key}"
        f"&deviceId={device_id}"
        f"&sms_number={number}"
        f"&sms_text={text}"
    )

    try:
        # Make the GET request to the Join API
        response = requests.get(api_url)
        
        # Raise an exception if the request returned an error (e.g., 401, 404)
        response.raise_for_status()

        # The Join API returns a JSON response. Let's check it.
        json_response = response.json()

        if json_response.get("success"):
            print("✅ Success! The command was sent to your device.")
            print("Please check your phone to confirm the message was sent.")
        else:
            # This usually means your API key or device ID was wrong
            print(f"❌ Error: The API returned an error.")
            print(f"   Message: {json_response.get('errorMessage', 'No error message provided.')}")

    except requests.exceptions.RequestException as e:
        print(f"❌ A network error occurred: {e}")
    except Exception as e:
        print(f"❌ An unexpected error occurred: {e}")


# --- EXECUTION ---
if __name__ == "__main__":
    send_join_message(API_KEY, DEVICE_ID, RECIPIENT_NUMBER, MESSAGE_TEXT)