Sidebar Menu

SimpleSMSSend

Send single, immediate text messages from your website or application with the SimpleSMSSend method. SMS Notify! uses DIDs or short codes assigned to your account license key to send MT text messages and receive MO text messages.

Endpoint

GET (HTTP): https://messaging.cdyne.com/Messaging.svc/SimpleSMSsend?PhoneNumber={PHONENUMBER}&Message={MESSAGE}&LicenseKey={LICENSEKEY}

Syntax

SimpleSMSSend(PhoneNumber, Message, LicenseKey)

Request Parameters

Parameter Name Description Data Type Required Sample Value
PhoneNumber

Input phone number to send SMS text to.

String True 17575449510
LicenseKey

Your license key, as required to invoke this web service.

GUID True F01d89fd-5155-5455-5585-e84ab8de8591
Message

Message to send to phone number

String True This is a sample message from SMS Notify!

Response

Returns: SimpleSMSSendResponse object

Code Samples

// Add this service reference to your project: http://sms2.cdyne.com/sms.svc?wsdl

namespace SimpleSMSSend
{
    class Program
    {
        static void Main(string[] args)
        {
            IsmsClient client = new IsmsClient("sms2wsHttpBinding");
            SMSResponse resp = client.SimpleSMSsend("17575449510", "Test Simple Message", new Guid("YOUR LICENSE KEY"));  // Single-line message request.
            // SMSResponse resp = client.SimpleSMSsend("17575449510", "SMS Simple Test" + "\n" + "Multi Line Message", new Guid("YOUR LICENSE KEY"));  // Multi-line message request.

            Console.WriteLine(resp.MessageID + " " + resp.SMSError.ToString());
            Console.ReadLine();
            client.Close();
        }
    }
}
' Add this service reference to your project: http://sms2.cdyne.com/sms.svc?wsdl

Imports SimpleSMS.WSDL

Module Module1

    Sub Main()

        Dim client As WSDL.IsmsClient = New WSDL.IsmsClient("sms2wsHttpBinding")
        Dim resp As SimpleSMS.WSDL.SMSResponse = client.SimpleSMSsend("17575449510", "Simple SMS", New Guid("YOUR LICENSE KEY"))  ' Single-line message request.
        ' Dim resp As SimpleSMS.WSDL.SMSResponse = client.SimpleSMSsend("17575449510", "Simple" & Environment.NewLine & "SMS", New Guid("YOUR LICENSE KEY"))  ' Multi-line message request.

        Console.WriteLine(Convert.ToString(resp.MessageID) & " " & "SMS Error:" & " " & Convert.ToString(resp.SMSError))
        Console.ReadLine()
        client.Close()

    End Sub

End Module
Dim oXMLHTTP
Set oXMLHTTP = CreateObject("Microsoft.XMLHTTP")
Set oDoc = CreateObject("MSXML2.DOMDocument")

Call oXMLHttp.Open("GET", "http://sms2.cdyne.com/sms.svc/SimpleSMSSend?PhoneNumber=7575449510&Message=SimpleSMSSend Test Message&LicenseKey=YOUR LICENSE KEY", False)
Call oXMLHttp.setRequestHeader("Content-Type", "text/xml")
Call oXMLHttp.send

MsgBox oXMLHTTP.responseText
<?php

// The following example was built using PHP 5.3.2. Your setup may differ, so please ensure that your PHP 5.x version supports the SOAPClient class.


// Create a new soap client based on the SMS Notify! WCF service
$client = new SoapClient('http://sms2.cdyne.com/sms.svc?wsdl');

// Specify required info to send a text message
$param = array(
  'PhoneNumber' => '7891234567',
  'LicenseKey' => '(your license key here)',
  'Message' => 'test'
);

// Send the text message
$result = $client->SimpleSMSsend($param);

// View the response from CDYNE
print_r($result);

?>
<?php

// The following example was built using PHP 5.3.2 using cURL

$url = 'http://sms2.cdyne.com/sms.svc/SimpleSMSsend?PhoneNumber=(To Phone Number)&Message=(Message)&LicenseKey=(Your License Key)';
$cURL = curl_init();

curl_setopt($cURL, CURLOPT_URL, $url);
curl_setopt($cURL, CURLOPT_HTTPGET, true);
curl_setopt($cURL, CURLOPT_HTTPHEADER, array('Content-Type: application/json', 'Accept: application/json'));

$result = curl_exec($cURL);
curl_close($cURL);

print_r($result);

?>
import socket, httplib, urllib, urllib2
import xml.etree.ElementTree as etree
import json
import time

class session:
    def __init__(self, license_key):
        self.__license_key = license_key
        self.__sms_action_url = "http://sms2.cdyne.com/sms.svc"
        self.__max_retries = 1

    def __xml_to_dictionary(self, xml):
        boolean_keys = ["Queued", "SMSIncomingMessages", "Sent", "Cancelled"]
        if type(xml) != etree.Element:
            root = etree.XML(xml)
        else:
            root = xml
        dictionary = {}
        if root is not None:
            for element in root.getchildren():
                element_name = element.tag.split("}")[1]
                element_value = element.text
                if element_name in boolean_keys:
                    if element_value == "true":
                        element_value = True
                    else:
                        element_value = False
                dictionary[element_name] = element_value
        return dictionary

    def __get_request(self, request):
        """
        Return contents of a given request
        """
        for i in range(0, self.__max_retries):
            try:
                return urllib2.urlopen(request).read()
            except urllib2.URLError:
                time.sleep(3)
            except httplib.BadStatusLine or httplib.InvalidURL:
                time.sleep(3)
            except socket.error or socket.timeout:
                time.sleep(3)
            except:
                import traceback
                traceback.print_exc()
        raise NameError("Failed to grab URL: %s", request)

    def __send_request(self, data, function):
        request_url = self.__sms_action_url + "/%s" % function
        request_url += "?%s" % urllib.urlencode(data)
        response = self.__get_request(request_url)
        return self.__xml_to_dictionary(response)


    def simple_sms_send(self, phone_number, message):
        data = {"PhoneNumber": phone_number,
                "LicenseKey": self.__license_key,
                "Message": message}
        return self.__send_request(data, "SimpleSMSSend")

license_key = "YOUR LICENSE KEY"
sms = session(license_key)

# Send a message
phone_number = "THE TO PHONE NUMBER"
message = "This is a test message from CDYNE"
sms.simple_sms_send(phone_number, message)
# Example 1

require 'net/http'
require 'URI'

puts URI.methods
url = URI.parse('http://sms2.cdyne.com/sms.svc/SimpleSMSsend?PhoneNumber=YourPhoneNumber&Message=HelloRubyWorld&LicenseKey=YourLicenseKey')
res = Net::HTTP.get_response(url)
data = res.body
puts data




# Example 2: Using a params object

require 'net/http'
require 'uri'

uri = URI("http://sms2.cdyne.com/sms.svc/SimpleSMSsend")

params = {
  :PhoneNumber => 'YourPhoneNumber',
  :Message => 'Hello From SMSNotify!',
  :LicenseKey => 'YourLicenseKey'
}

uri.query = URI.encode_www_form(params)
res = Net::HTTP.get_response(uri)
puts res.body if res.is_a?(Net::HTTPSuccess)
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Properties;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

public final class SimpleSMSSend{
    public static void main(String[] args) {
        try {
            URL url = new URL("http://sms2.cdyne.com/sms.svc/SimpleSMSsend?"
                            + "PhoneNumber=15551234567"
                            + "&Message=JAVA+Test"
                            + "&LicenseKey=YOUR LICENSE KEY");

            try {
                InputStream in = url.openStream();
                StreamSource source = new StreamSource(in);
                printResult(source);
            } catch (java.io.IOException e) {
                e.printStackTrace();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

    private static void printResult(Source source) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            StreamResult sr = new StreamResult(bos);
            Transformer trans = TransformerFactory.newInstance().newTransformer();
            Properties oprops = new Properties();
            oprops.put(OutputKeys.OMIT_XML_DECLARATION, "yes");
            trans.setOutputProperties(oprops);
            trans.transform(source, sr);

            System.out.println("**** Response ******");
            System.out.println(bos.toString());

            bos.close();
            System.out.println();
        } catch (Exception e) {
        }
    }
}
{
  "Cancelled": true,
  "MessageID": "1627aea5-8e0a-4371-9022-9b504344e724",
  "Queued": true,
  "ReferenceID": "String content",
  "SMSError": 0,
  "SMSIncomingMessages": null,
  "Sent": true,
  "SentDateTime": "\/Date(928164000000-0400)\/"
}
<SMSResponse xmlns="http://sms2.cdyne.com">
  <Cancelled>true</Cancelled>
  <MessageID>1627aea5-8e0a-4371-9022-9b504344e724</MessageID>
  <Queued>true</Queued>
  <ReferenceID>String content</ReferenceID>
  <SMSError>NoError</SMSError>
  <SMSIncomingMessages i:nil="true" />
  <Sent>true</Sent>
  <SentDateTime>2020-05-31T11:20:00</SentDateTime>
</SMSResponse>