WAservix WhatsApp API & SMS Gora SMS Gateway: Send From Your Own Number (Node.js + Python)

Most messaging APIs make you rent a sender ID, wait for template approval, and pay per message before you've written a single line of code. If you just want your app to text a customer "your order is ready" or "your code is 482913", that's a lot of ceremony.

This post shows a lighter route: the WAservix WhatsApp API sends WhatsApp messages from your own WhatsApp number, and the SMS Gora SMS Gateway sends SMS from your own Android phone and SIM card. Both are part of Tekservix, and both are plain REST + webhooks, so they work from any stack.

Disclosure: this article is written by the Tekservix team. The code below is copied from our public docs and runs as-is once you add a key.

TL;DR: WAservix is a WhatsApp API gateway for your own number. SMS Gora is an Android SMS gateway that turns your phones into an SMS API. Same REST style, same webhooks, any language.

What you'll build

1. Send a WhatsApp message (and a PDF invoice) from Node.js with the WAservix WhatsApp API
2. Send an SMS, pick a specific SIM, and schedule it from Python with the SMS Gora SMS Gateway
3. Receive replies and delivery updates with signed webhooks
4. Handle rate limits and retries without sending twice

Why "your own number" matters

	Classic messaging APIs	WAservix WhatsApp API / SMS Gora SMS Gateway
Sender	Rented number or sender ID	Your existing WhatsApp number / your SIM cards
Approval	Business verification, message templates	None: link the number like WhatsApp Web, or install the Android app
Cost model	Per message	Flat monthly plan (SMS is billed by your own operator like any text)
Replies	Extra setup	Webhooks out of the box
Free trial	Usually needs a card	3-day trial, no card

Customers see a number they already know, and replies land in the same chat.

Part 1: WAservix WhatsApp API with Node.js

Create a key under WAservix → Devices → API key (it starts with wpk_). Keep it on the server, never in a browser or mobile app.

# .env  (node --env-file=.env app.mjs, Node 20.6+)
WASERVIX_KEY=wpk_your_key
WASERVIX_WEBHOOK_SECRET=your_webhook_secret

Send a message

const res = await fetch('https://tekservix.com/waservix/api/send-message', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.WASERVIX_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    to: '[phone]',
    text: 'Hello Sam, your order is ready'
  }),
});
const json = await res.json();
if (!res.ok) throw new Error(json.message || res.statusText);
console.log(json.data); // { status: 'in_progress', msgId: ... }

Messages are queued and sent one at a time per number, so you get an answer instantly with a msgId.

Send a document or image

Add imageUrl, videoUrl, audioUrl or documentUrl with a public https link. Groups work too: put the group JID ([e-mail]) in to.

body: JSON.stringify({
  to: '[phone]',
  text: 'Your invoice',
  documentUrl: 'https://example.com/inv-1042.pdf',
  fileName: 'Invoice-1042.pdf'
})

Track it

GET /waservix/api/messages/{id}/info returns queued, sent, delivered, read, played or failed. Better: let webhooks tell you.

Receive messages with Express

import crypto from 'node:crypto';
import express from 'express';
const app = express();

app.post('/webhooks/waservix', express.json(), (req, res) => {
  const got = Buffer.from(req.get('X-Webhook-Signature') || '');
  const secret = Buffer.from(process.env.WASERVIX_WEBHOOK_SECRET);
  if (got.length !== secret.length || !crypto.timingSafeEqual(got, secret)) {
    return res.sendStatus(401);
  }
  res.sendStatus(200); // answer fast, then do the work
  const event = req.body;
  if (event.event === 'messages.received') {
    const m = event.data.messages;
    console.log(m.key.cleanedSenderPn, m.messageBody);
  }
});

app.listen(3000);

Full guide: WAservix WhatsApp API for Node.js · all WAservix WhatsApp API docs.

Part 2: SMS Gora SMS Gateway with Python

The SMS Gora SMS Gateway turns Android phones you own into an SMS gateway API. Link a phone, create a key under SMS Gora → API keys (starts with sgk_), and send through its SIM cards.

pip install requests flask
export SMSGORA_KEY="sgk_your_key"
export SMSGORA_WEBHOOK_SECRET="your_webhook_secret"

Send an SMS

/send-sms picks your best online phone. Recipients can be a list of up to 1,000.

import os
import requests

r = requests.post(
    'https://tekservix.com/smsgora/api/v1/send-sms',
    headers={'x-api-key': os.environ['SMSGORA_KEY']},
    json={
        'recipients': ['[phone]'],
        'message': 'Your code is 482913'
    },
    timeout=30,
)
r.raise_for_status()
print(r.json())  # includes message_ids

Choose the phone, the SIM, and the time

Dual-SIM phone? sim_slot 0 is SIM 1, 1 is SIM 2. schedule_at sends later.

r = requests.post(
    'https://tekservix.com/smsgora/api/v1/devices/42/send-sms',
    headers={'x-api-key': os.environ['SMSGORA_KEY']},
    json={
        'recipients': ['[phone]'],
        'message': 'Your appointment is tomorrow at 10:00',
        'sim_slot': 1,
        'schedule_at': '2026-12-01T08:00:00Z'
    },
    timeout=30,
)

Statuses move queued → dispatched → sent → delivered (or failed with a reason).

Verify webhooks with HMAC (Flask)

Each request carries X-SmsGora-Signature: sha256=..., an HMAC-SHA256 of the raw body.

import hashlib, hmac, os
from flask import Flask, request, abort

app = Flask(__name__)

@app.post('/webhooks/smsgora')
def smsgora_webhook():
    expected = 'sha256=' + hmac.new(
        os.environ['SMSGORA_WEBHOOK_SECRET'].encode(),
        request.get_data(), hashlib.sha256
    ).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get('X-SmsGora-Signature', '')):
        abort(401)
    event = request.get_json()
    if event['event'] == 'sms.received':
        print(event['data']['from'], event['data']['message'])
    return '', 200

Full guide: SMS Gora SMS Gateway for Python · all SMS Gora SMS Gateway API docs.

Part 3: Production checklist

• Placeholders only. wpk_your_key, sgk_your_key, the [phone]xxx numbers (reserved for fiction) and IDs like 42 or 1873 are examples. Every call needs your own key, and a key only sees its own phones and messages.
• Keys stay server-side. Your mobile app or frontend talks to your server, which calls the API.
• Rate limit: 300 requests a minute per key. On 429, wait for Retry-After seconds.
• Error codes: 401 wrong key, 402 no active plan for that number/phone, 409 number or phone not connected.
• Don't blindly retry a send. Retry 5xx and network errors with back-off, but check the message status first, or you might text someone twice.
• Consent first. Only message people who expect to hear from you. WAservix adds number protection by default (a gradual daily warm-up), because WhatsApp bans numbers that spam.

Same API, any stack

For both the WAservix WhatsApp API and the SMS Gora SMS Gateway, copy-paste guides exist for Python, Django, Node.js, PHP, Laravel, WordPress, Java, Spring Boot, C#/.NET, Go and Ruby on Rails, and there are WordPress plugins if you'd rather not write code at all.

Going further

Once the WAservix WhatsApp API and SMS Gora SMS Gateway are sending, the rest of the Tekservix platform plugs into the same numbers:

• AI Sales Agent: answers customer questions and sells on WhatsApp and SMS 24/7, using your products and prices.
• App Studio: turn your website into an iOS and Android app, or build a native one, with store-ready builds.
• Takesuite: schedule social media posts with AI.

WAservix and SMS Gora both come with a 3-day free trial, no card needed: see pricing.

---

What are you sending from your app today: OTPs, order updates, appointment reminders? Tell me in the comments, and I'm happy to help with the integration.