Add SMS to a Base44 app: backend functions that text from your own phone

What you need

• A Base44 app on the Builder plan or higher. Backend functions and the Secrets page need it.
• A textbee account with the Android app installed on the phone that holds the SIM, and an API key from the dashboard.
• A second phone, or a friend, to text the textbee phone when you test replies.
• The textbee app on the phone. Download the app, then create an API key in the dashboard.

Send SMS from Base44

Backend functions run on Deno on Base44's servers. The Secrets page appears in the dashboard once the app has a backend function, and functions read secrets at run time.

1. 1

   Prompt for the function

   Paste the prompt from this page into the Base44 chat. It creates a backend function under base44/functions and asks for the key. Keys pasted into the chat are saved as secrets.

2. 2

   Check the secret

   Open Dashboard, Secrets. If the key is not there, click Add Secret. Secret names use underscores, no spaces. Import .env adds several at once.

   Field	Value
   Secret Name	TEXTBEE_API_KEY
   Secret Value	Your key from the textbee dashboard

3. 3

   Read the core of the function

   Whatever wrapper Base44 generates, the send is one fetch call with the key from the environment.

   base44/functions/sendSms/entry.ts

   Copy

   async function sendSms(to: string, message: string) {
     const res = await fetch('https://api.textbee.dev/api/v1/gateway/send-sms', {
       method: 'POST',
       headers: {
         'x-api-key': Deno.env.get('TEXTBEE_API_KEY') ?? '',
         'Content-Type': 'application/json',
       },
       body: JSON.stringify({ recipients: [to], message }),
     })
     return res.json()
   }

4. 4

   Run a test

   Open Dashboard, Code, select the function, click Test Function, enter a payload with your own number such as +12015550123, and click Run Function. The response shows data.success true.

Receive SMS in Base44

Each deployed function answers at https://<your-app-domain>/functions/<function-name>. A direct HTTP call carries no Base44 user, so the webhook function uses service-role access to write data.

1. 1

   Prompt for the webhook function

   Ask for a backend function named textbeeWebhook that checks X-Signature against TEXTBEE_WEBHOOK_SECRET, stores sender and message with service-role access, and returns 200.

   base44/functions/textbeeWebhook/entry.ts

   Copy

   async function signatureMatches(raw: string, signature: string | null): Promise<boolean> {
     const secret = Deno.env.get('TEXTBEE_WEBHOOK_SECRET') ?? ''
     const key = await crypto.subtle.importKey(
       'raw',
       new TextEncoder().encode(secret),
       { name: 'HMAC', hash: 'SHA-256' },
       false,
       ['sign'],
     )
     const mac = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(raw))
     const expected = Array.from(new Uint8Array(mac), (b) => b.toString(16).padStart(2, '0')).join('')
     if (!signature || signature.length !== expected.length) return false
     let diff = 0
     for (let i = 0; i < expected.length; i++) diff |= expected.charCodeAt(i) ^ signature.charCodeAt(i)
     return diff === 0
   }

2. 2

   Register the function URL

   In the textbee dashboard open Webhooks and add https://<your-app>.base44.app/functions/textbeeWebhook with the MESSAGE_RECEIVED event and the same signing secret.

3. 3

   Text the phone

   Send a text to the textbee phone from another number. The record appears in your app, and the function log in the dashboard shows the delivery.

Paste this prompt into Base44

The prompt below carries the endpoints, the payloads, where the key may live and the Base44 details from this page. Change the line that starts with What I want, and Base44 builds the feature without guessing an endpoint.

Add SMS to the app I am building in Base44. Use textbee, an SMS gateway that sends and receives SMS through my own Android phone.

Facts about the textbee API. Use only these. Do not invent endpoints or fields.
- Send an SMS: POST https://api.textbee.dev/api/v1/gateway/send-sms with the header x-api-key: <TEXTBEE_API_KEY> and a JSON body like {"recipients": ["+12015550123"], "message": "Hello"}. recipients must be a JSON array of E.164 numbers, even for one number. Optional fields: deviceId, simSubscriptionId, scheduledAt (ISO 8601, in the future). The response is {"data": {"success": true, "smsBatchId": "..."}}.
- Check delivery or read replies: GET https://api.textbee.dev/api/v1/gateway/messages with the same header. Filters: direction=received, smsBatchId=<id from the send>, from and to as ISO timestamps. Each row has a status such as sent, delivered, failed or received.
- Receive an SMS: textbee posts JSON to a webhook URL I register in the dashboard. A MESSAGE_RECEIVED delivery has these top-level fields: smsId, message, deviceId, webhookSubscriptionId, webhookEvent, idempotencyKey, sender, receivedAt. The header X-Signature holds an HMAC-SHA256 hex digest of the raw body, keyed with the signing secret I set on the webhook. Retries reuse the same idempotencyKey.
- Limits: One Android phone sends roughly 10 to 15 messages a minute. Text only, no MMS. Messages over 160 characters are split into segments.

Rules:
- Store the API key as a secret named TEXTBEE_API_KEY. Call textbee only from server-side code, never from code that runs in the browser.
- Do not ask me to paste the real key into this chat. Tell me where to add the secret instead.
- For incoming texts, create a public server endpoint, check the X-Signature header against a secret named TEXTBEE_WEBHOOK_SECRET, and ignore a repeated idempotencyKey.

What I want: Text the client when their order status changes to Shipped, and save any reply on the order.

Base44 specifics you should know:
- Use a Base44 backend function (Deno) for every textbee call. Backend functions need the Builder plan.
- Read the key with Deno.env.get or secrets.get from base44:runtime, inside the handler.
- The webhook function is called by textbee without a Base44 user, so write data with asServiceRole.
- A deployed function answers at https://<app-domain>/functions/<function-name>. Tell me the exact URL to register.

Build it, tell me where to add each secret in Base44, and add a way to send one test message to my own number.

Features to build

Status change texts

When an order, a job or a ticket changes status, a backend function texts the client the new status in one line.

Lead capture

A landing page form saves the lead and texts the owner at once, so the first reply goes out while the lead is still on the page.

Staff shift reminders

A scheduled function texts each staff member their shift for tomorrow. A reply of NO flags the shift for cover.

Why Base44 builders text from their own phone

Fill the missing piece

Base44 sends email and push notifications out of the box but not SMS. One backend function adds texts without leaving the builder.

Clients reply to a real number

Status updates from a mobile number feel personal, and the replies come back into the same app that holds the order.

Predictable bill

Your Base44 plan and a flat textbee plan. No per-message fee stacking up as the app grows.

A cloud SMS provider in Base44 vs textbee in Base44

Per-message prices by provider and country, with sources and dates, are on the provider comparison pages.

What works and what does not

What Base44 charges

Backend functions need the Base44 Builder plan or higher, $40 a month billed annually. Free and Starter cannot run the server code that keeps the key safe. base44.com, checked on October 22, 2026. textbee itself charges a flat monthly plan with messages included; see pricing.

Frequently asked questions

Sources

1. base44.com, checked on October 22, 2026
2. docs.base44.com: Using integrations and backend functions, checked on October 22, 2026
3. docs.base44.com: Backend functions overview, checked on October 22, 2026

Read next

• Order and delivery notifications with SMS from your own Android number
• Form and lead follow-up with SMS from your own Android number
• Build with AI: one prompt for every builder
• Keep the phone online
• Add SMS to an app you build in Cursor: one prompt, a rule file and the MCP server
• GoHighLevel SMS integration: send and receive texts through your own phone
• All integrations