SMS Gateway API Documentation

XLSM VBA Integration

This section explains how to integrate SMS Gateway with an XLSM file using VBA.

1. Setup

Follow these steps to configure Excel (XLSM) for SMS automation:

1. Open Excel and press ALT + F11 to open the VBA Editor.
2. Insert a new module and paste the following VBA script:

                            Sub SendSMSWithDelay()
                            Dim ws As Worksheet
                            Dim i As Integer
                            Dim phoneNumber As String, message As String, status As String
                            Dim http As Object, JSON As String
                            Dim intervalSec As Integer
                            
                            Set ws = ThisWorkbook.Sheets("Sheet1")
                            intervalSec = 10 ' Set delay in seconds
                            
                            i = 2 ' Start from the second row
                            While ws.Cells(i, 1).Value <> ""
                                phoneNumber = ws.Cells(i, 1).Value
                                message = ws.Cells(i, 2).Value
                                status = ws.Cells(i, 3).Value
                                
                                If status <> "Sent" Then
                                    JSON = "[{""mobile"":""" & phoneNumber & """,""text"":""" & message & """}]"
                                    
                                    Set http = CreateObject("MSXML2.XMLHTTP")
                                    http.Open "POST", "https://api.smstext.app/push", False
                                    http.setRequestHeader "Content-Type", "application/json"
                                    http.setRequestHeader "Authorization", "Basic " & Base64Encode("apikey:YOUR_API_KEY")
                                    http.Send JSON
                                    
                                    If http.Status = 200 Then
                                        ws.Cells(i, 3).Value = "Sent"
                                        Application.Wait (Now + TimeValue("00:00:" & intervalSec))
                                    End If
                                End If
                                
                                i = i + 1
                            Wend
                            End Sub
                            

2. Automate Execution

To run the script automatically:

• Go to Developer > Macros and select SendSMSWithDelay.
• Click Run to execute the macro.
• You can also assign this macro to a button in Excel for easy execution.

3. Using Status Column

Ensure there is a "Status" column in your sheet to prevent duplicate messages. The script marks messages as "Sent" after sending.

4. Debugging

Use Debug.Print in VBA to check response errors.

Now, SMS automation with controlled intervals in Excel VBA is ready! 🎉

Google Sheets Integration

This section explains how to integrate SMS Gateway with Google Sheets using Google Apps Script.

1. Setup

Follow these steps to configure Google Sheets for SMS automation:

1. Open Google Sheets and go to Extensions > Apps Script.
2. Paste the following script:

                            function sendSMSWithDelay() {
                                var sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Sheet1"); 
                                var data = sheet.getDataRange().getValues();
                                var intervalSec = 10; // Change interval (e.g., 10 seconds)
                                var properties = PropertiesService.getScriptProperties();
                                
                                var lastProcessedRow = parseInt(properties.getProperty("lastProcessedRow")) || 1;
                                
                                for (var i = lastProcessedRow; i < data.length; i++) {
                                    var phoneNumber = data[i][0];
                                    var message = data[i][1];
                                    var status = data[i][2];

                                    if (status !== "Sent") {
                                        var options = {
                                            "method": "post",
                                            "headers": {
                                                "Authorization": "Basic " + Utilities.base64Encode("apikey:YOUR_API_KEY"),
                                                "Content-Type": "application/json"
                                            },
                                            "payload": JSON.stringify([{
                                                "mobile": phoneNumber,
                                                "text": message
                                            }])
                                        };

                                        try {
                                            var response = UrlFetchApp.fetch("https://api.smstext.app/push", options);
                                            if (response.getResponseCode() === 200) {
                                                sheet.getRange(i + 1, 3).setValue("Sent");
                                                properties.setProperty("lastProcessedRow", i + 1);
                                                Utilities.sleep(intervalSec * 1000);
                                            }
                                        } catch (e) {
                                            Logger.log("Error sending to " + phoneNumber + ": " + e.toString());
                                        }
                                    }
                                }
                                
                                properties.setProperty("lastProcessedRow", 1);
                            }
                                

2. Automate with Triggers

To send SMS messages automatically at intervals, create a trigger:

• Go to Apps Script and click on the clock icon (Triggers).
• Click on + Add Trigger.
• Select function: sendSMSWithDelay.
• Event source: Time-driven.
• Set interval (e.g., every 5 minutes).

3. Using Status Column

Ensure there is a "Status" column in your sheet to prevent duplicate messages. The script marks messages as "Sent" after sending.

4. Testing & Debugging

Check logs in Apps Script by clicking View > Executions to debug errors.

5. Customization

• Modify intervalSec to change delay between messages.
• Add a cell in Google Sheets where users can set their own interval dynamically.

Now, SMS automation with controlled intervals is ready! 🎉

Shopify Webhook Integration

Step 1: Create a Webhook in Shopify

1. Go to Shopify Admin and navigate to Settings > Notifications.
2. Scroll down to the Webhooks section and click Create Webhook.
3. Select:
   • Event: Order Creation
   • Format: JSON
   • URL: Your webhook script URL (e.g., https://yourwebsite.com/webhook-handler.php)
   • Webhook API Version: Latest available
4. Click Save.

Step 2: Create the Webhook Handler

Use the following PHP script to process the webhook and send SMS notifications.

                                <?php
                                // Read data from Shopify
                                $data = json_decode(file_get_contents("php://input"), true);

                                if (!$data) {
                                    http_response_code(400);
                                    exit("No data received.");
                                }

                                // Extract necessary details
                                $customerPhone = $data['customer']['phone'] ?? null;
                                $orderId = $data['id'] ?? null;
                                $totalPrice = $data['total_price'] ?? '0.00';

                                if (!$customerPhone) {
                                    http_response_code(400);
                                    exit("No phone number found for customer.");
                                }

                                $smsMessage = "Comanda #$orderId a fost primită! Total: $$totalPrice. Vă mulțumim!";

                                $apiKey = "YOUR_API_KEY";
                                $apiUrl = "https://api.smstext.app/push";
                                $headers = [
                                    "Authorization: Basic " . base64_encode("apikey:" . $apiKey),
                                    "Content-Type: application/json"
                                ];

                                $postData = json_encode(
                                [
                                    [
                                        'mobile' => $phone_number,
                                        'text' => $message
                                    ]
                                ]);

                                $ch = curl_init($apiUrl);
                                curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                curl_setopt($ch, CURLOPT_POST, true);
                                curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
                                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                                $response = curl_exec($ch);
                                curl_close($ch);

                                file_put_contents("sms_log.txt", "Sent SMS to $customerPhone: $smsMessage\nResponse: $response\n", FILE_APPEND);

                                http_response_code(200);
                                exit("Webhook received and processed.");
                                ?>
                            

Step 3: Testing the Integration

• Place a test order in Shopify with a valid phone number.
• Check the sms_log.txt file to confirm the message was sent.
• Monitor SMS deliveries through SMS Gateway API.

PrestaShop Integration

Integrate SMS Gateway with PrestaShop for real-time SMS notifications.

Method 1: Webhook (Instant SMS Notifications)

This method sends SMS immediately when a new order is placed.

1. Go to **PrestaShop Admin Panel**.
2. Navigate to Advanced Parameters > Webservice and enable web services.
3. Create a webhook that triggers when a new order is placed.
4. Configure the webhook to send data to a custom PHP script.

PHP Webhook Script (save as `webhook_sms.php`)

Place this file on your server and configure the webhook in PrestaShop to call it.

                                <?php
                                $data = json_decode(file_get_contents("php://input"), true);
                                $phone = $data['customer']['phone'];
                                $orderId = $data['id_order'];
                                $message = "Order #$orderId has been received!";

                                $apiKey = "YOUR_API_KEY";
                                $apiUrl = "https://api.smstext.app/push";
                                $headers = [
                                    "Authorization: Basic " . base64_encode("apikey:" . $apiKey),
                                    "Content-Type: application/json"
                                ];

                                $postData = json_encode([
                                    "mobile" => $phone,
                                    "text" => $message
                                ]);

                                $ch = curl_init($apiUrl);
                                curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
                                curl_setopt($ch, CURLOPT_POST, true);
                                curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
                                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                                $response = curl_exec($ch);
                                curl_close($ch);
                                file_put_contents("sms_log.txt", "Sent SMS to $phone: $message\nResponse: $response\n", FILE_APPEND);
                                ?>
                            

Where to place this file?

• Upload `webhook_sms.php` to your web server.
• Set your PrestaShop webhook to call `https://yourdomain.com/webhook_sms.php`.
• Ensure the file has proper permissions and can be accessed by the webhook.

Advantages: Instant SMS sending, no delay.