Developers / SMS Quickstart

SMS Quickstart

The fastest way to get started with ClickSend API in your preferred coding language.

Choose your language:

Resources:

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

Install via Cocoapods

CocoaPods is a dependency manager for Cocoa projects. For usage and installation instructions, visit their website.

To integrate ClickSendSwift into your Xcode project using CocoaPods, specify it in your Podfile:

pod 'ClickSendSwift'

Update Swift Version

The ClickSend SDK was built using Swift Version 4.2.

To update the language version, select Pods within the project from the left panel > Targets > ClickSendSwift > Swift Compiler - Language > Choose Swift 4.2. Repeat these steps for Alamofire.

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

import ClickSendSwift
import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "API_KEY") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let message = SmsMessage(
   source: "SOURCE",
   body: "MESSAGE",
   to: "TO_PHONE_NUMBER")

let smsCollection = SmsMessageCollection(messages: [message])

SMSAPI.smsSendPost(smsMessages: smsCollection) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("bad json")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

The code explained

Import libraries

Prepare your environment to use the ClickSend API by importing the SDK and required libraries.

import ClickSendSwift
import Alamofire

Authorisation

Next, add your API credentials so you can use the ClickSend API in your project.

In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API key. These can be found in your Dashboard here.

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "API_KEY") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

Configure your message

It’s time to configure the content of your message and specify who you’re sending to. This code includes everything you need to send an SMS message. To see what other parameters you can include, see our full API reference.

Now, it’s a simple matter of a few tweaks:

Replace SOURCE with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.
Replace MESSAGE with your own message.
Replace TO_PHONE_NUMBER with your own mobile number, including country code. For example, if you have an Australian number, it will start with +61.

let message = SmsMessage(
   source: "SOURCE",
   body: "MESSAGE",
   to: "TO_PHONE_NUMBER")

Create an SMS message collection

Next, we’ll create a collection and add the SmsMessage that you created earlier.

let smsCollection = SmsMessageCollection(messages: [message])

Send SMS message

Finally, try to call the smsSendPost method using the smsCollection you created earlier. If everything works as expected then it will print the formatted response.

If an exception occurs during the API call, the completion handler will log the outputted details. This structure helps you handle both successful API calls and potential errors that might occur during the process.

SMSAPI.smsSendPost(smsMessages: smsCollection) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("bad json")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

Download and install Ruby (choose the first installer in the 'WITH DEVKIT' list).
Install json if you haven’t already “gem install json”
Install ClickSend client “gem install clicksend_client”

Full snippet

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API Key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  config.username = USERNAME
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::SMSApi.new

# SmsMessageCollection | SmsMessageCollection model
sms_messages = ClickSendClient::SmsMessageCollection.new

sms_messages.messages = [
  ClickSendClient::SmsMessage.new(
    "to": "TO_PHONE_NUMBER",
    "source": "SOURCE",
    "body": "MESSAGE"
  ),
]

begin
  # Send sms message(s)
  result = api_instance.sms_send_post(sms_messages)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts e
  puts "Exception when calling SMSApi->sms_send_post: #{e.response_body}"
end

The code explained

Import functions

Start by preparing your environment to use the ClickSend API. Import the necessary modules, including the ClickSend client library and exception handling classes.

require 'clicksend_client'
require 'json'

Authorisation

Next, set up your Username and API Key so you can use the ClickSend API in your project.

In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API Key. These can be found on the Dashboard here.

ClickSendClient.configure do |config|
  config.username = USERNAME
  config.password = 'API_KEY'
end

Create an instance of the API class

The following line of code will create an instance of the ACCOUNTAPI class, which is configured to use the APICLIENT with the credentials that we set up in the previous step. This instance will allow you to interact with the ClickSend API's account-related functionality.

api_instance = ClickSendClient::SMSApi.new

Configure your message

Next, configure the content of your message and define who you’re sending to-and-from.

Here you will want to replace the placeholder ‘SOURCE’ with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.

Replace “MESSAGE” with a message of your choice, and replace “TO_PHONE_NUMBER” with the number that you’ll be sending the message to.

For testing purposes, we recommend you start by sending to your own number.

For additional properties that you can use here, see the Full API Reference.

sms_messages = ClickSendClient::SmsMessageCollection.new

sms_messages.messages = [
  ClickSendClient::SmsMessage.new(
    "to": "+61411111111",
    "source": "myNumber",
    "body": "test message"
  ),
]

Send SMS message

Finally, try to call the SMS_SEND_POST method using the API_INSTANCE you've created. If everything works as expected then it will print the formatted response.

If an exception occurs during the API call, it catches the APIEXCEPTION and prints an error message with the exception details. This structure helps you handle both successful API calls and potential errors that might occur during the process.

begin
  # Send sms message(s)
  result = api_instance.sms_send_post(sms_messages)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts e
  puts "Exception when calling SMSApi->sms_send_post: #{e.response_body}"
end

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

To install the bindings via Composer, run the following command in terminal, inside your project directory:

composer require clicksend/clicksend-php

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$config = ClickSend\Configuration::getDefaultConfiguration()
    ->setUsername('USERNAME')
    ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\SMSApi(new GuzzleHttp\Client(),$config);

$msg = new \ClickSend\Model\SmsMessage();
$msg->setSource("SOURCE");
$msg->setBody("MESSAGE"); 
$msg->setTo("TO_PHONE_NUMBER");

$sms_messages = new \ClickSend\Model\SmsMessageCollection(); 
$sms_messages->setMessages([$msg]);

try {
    $result = $apiInstance->smsSendPost($sms_messages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMSApi->smsSendPost: ', $e->getMessage(), PHP_EOL;
}
?>

The code explained

Include files

Start by preparing your environment to use the ClickSend API by including the required autoload file. This will automatically load the classes you need without you having to explicitly include them.

require_once(__DIR__ . '/vendor/autoload.php');

Authorisation

Next, add your API credentials so you can use the ClickSend API in your project.

In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API key. These can be found in your Dashboard here.

$config = ClickSend\Configuration::getDefaultConfiguration()
    ->setUsername('USERNAME')
    ->setPassword('API_KEY');

Create an instance of the API class

The following snippet of code will create an instance of the SMSApi class, which is configured to work with the credentials that we set up in the previous step. This instance will be called in the following steps, allowing you to interact with ClickSend’s SMS functionality.

$apiInstance = new ClickSend\Api\SMSApi(new GuzzleHttp\Client(),$config);

Configure your message

Now, it’s a simple matter of a few tweaks:

Replace SOURCE with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.
Replace MESSAGE with your own message.
Replace TO_PHONE_NUMBER with your own mobile number, including country code. For example, if you have an Australian number, it will start with +61.

$msg = new \ClickSend\Model\SmsMessage();
$msg->setSource("SOURCE");
$msg->setBody("MESSAGE"); 
$msg->setTo("TO_PHONE_NUMBER");

Create an SMS message collection

Next, we’ll create a collection and add the SmsMessage that you created earlier.

$sms_messages = new \ClickSend\Model\SmsMessageCollection(); 
$sms_messages->setMessages([$msg]);

Send SMS message

Finally, try to call the smsSendPost method using the apiInstance you created earlier. If everything works as expected then it will print the formatted response.

If an exception occurs during the API call, it catches the Exception and prints an error message with the exception details. This structure helps you handle both successful API calls and potential errors that might occur during the process.

try {
    $result = $apiInstance->smsSendPost($sms_messages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMSApi->smsSendPost: ', $e->getMessage(), PHP_EOL;
}
?>

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

Install via Github

Our Perl SDK is hosted on Github, and can be installed by downloading the repository and copying the contents of the lib directory to a location that perl searches.

Note: git needs to be installed first using your operating system’s usual method. e.g. “sudo apt update; sudo apt install git” for Debian/Ubuntu systems or “sudo yum install git” for RedHat/CentOS.

git clone https://github.com/ClickSend/clicksend-perl.git

Copy the WWW directory and contents from the lib directory created above to your project’s directory or to one of the system locations that Perl searches. To view the locations that Perl searches on your system, run:

perl -e 'for (@INC) { print "$_\n"; }'

Individual ClickSend modules can then be included in your code with the “use” directive. e.g.

use WWW::ClickSendClient::SMSApi;

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

#!/usr/bin/perl -w
use WWW::ClickSendClient::SMSApi;
use WWW::ClickSendClient::Object::SmsMessageCollection;

my $USERNAME = 'my-clicksend-username@example.com';
my $API_KEY = 'FEDC0123-0123-4567-89AB-CDEF01234567';
my $TO_PHONE_NUMBER = '+61411111111';
my $MESSAGE = "Test message from perl";

my $api = WWW::ClickSendClient::SMSApi->new(username => "$USERNAME",
password => "$API_KEY");

my $sms_messages = WWW::ClickSendClient::Object::SmsMessageCollection-
>new(
  messages => [{
    source => 'perl',
    to => "$TO_PHONE_NUMBER",
    body => "$MESSAGE"
  }]);
  
my $json_output = $api->sms_send_post(sms_messages => $sms_messages);

print $json_output;

The code: explained

Import functions

Start by preparing your environment to use the ClickSend API. Import the necessary modules, including the ClickSend SMS API and Message Collection object.

use WWW::ClickSendClient::SMSApi;
use WWW::ClickSendClient::Object::SmsMessageCollection;

Authorisation and create an instance of the API class

Next, set up your Username and API Key so you can use the ClickSend API in your project.

In the following snippet, simply replace the placeholders $USERNAME and $API_KEY with your own Username and API Key. These can be found in the Dashboard here.

This API instance returned from this call will allow you to interact with the ClickSend API's account-related functionality.

my $api = WWW::ClickSendClient::SMSApi->new(
username => "$USERNAME",
password => "$API_KEY");

Configure your message

Next, configure the content of your message and define who you’re sending to-and- from.

Here you will want to replace the placeholder ‘$SOURCE’ with your preferred source (eg. the name of your application). This is not seen by recipients but will help you to identify messages sent from various applications.

Replace “$MESSAGE” with a message of your choice, and replace “$TO_PHONE_NUMBER” with the number that you’ll be sending the message to.

For testing purposes, we recommend you start by sending to your own number.

The messages parameter is an array of hashes. Each hash makes up a single SMS message to be sent. In this example we only include a single SMS message.

For additional properties that you can use here, see the Full API Reference.

my $sms_messages = WWW::ClickSendClient::Object::SmsMessageCollection-
>new(
  messages => [{
    source => "$SOURCE",
    to => "$TO_PHONE_NUMBER",
    body => "$MESSAGE"
  }]);

Send SMS message

Finally, try to call the SMS_SEND_POST method using the API_INSTANCE you've created. If everything works as expected then it will print the response as raw JSON. The outcome of the call can be seen from the http_code and response_code attributes in the JSON response. There is also an array called ‘messages’ within the ‘data’ structure and each message within this array has a ‘status’ attribute.the formatted response.

my $json_output = $api->sms_send_post(sms_messages => $sms_messages);
print $json_output;

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.
Make sure you’re using the latest version of Python.

Installation

Install Typescript

You will need to install TypeScript to compile the code. Use the following command:

npm install typescript

Compile TypeScript into JavaScript

Compile TypeScript into JavaScript by running the following commands:

npm add request http bluebird @types/node
tsc --target es5 /node_modules/clicksend/api.ts

Add the SDK to your project

Copy the api.js file along with the node_modules directory into your project to use the library. Include this in your file to use the SDK:

var api = require('./node_modules/clicksend/api.js');

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API Key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

var api = require('./api.js');

var smsMessage = new api.SmsMessage();

smsMessage.source = "SOURCE";
smsMessage.body = "MESSAGE";
smsMessage.to = "TO_PHONE_NUMBER";

var smsApi = new api.SMSApi("USERNAME", "API_KEY");

var smsCollection = new api.SmsMessageCollection();

smsCollection.messages = [smsMessage];

smsApi.smsSendPost(smsCollection)
.then(function(response) {
  console.log(response.body);
})
.catch(function(err) {
  console.error(err.body);
});

The code explained

Import modules

Prepare your environment to use the ClickSend API by importing the required SDK and required modules.

var api = require('./api.js');

Create an instance of the API class

The following snippet of code will create an instance of the SmsMessage class. This instance will be called in the following steps, allowing you to interact with ClickSend’s SMS-related functionality.

var smsMessage = new api.SmsMessage();

Configure your message

It’s time to configure the content of your message and specify who you’re sending to. This code includes everything that you need to send an SMS message. To see what other parameters you can include, see our full API reference.

Now, it’s a simple matter of a few tweaks:

Replace SOURCE with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.
Replace MESSAGE with your own message.
Replace TO_PHONE_NUMBER with your own mobile number, including country code. For example, if you have an Australian number, it will start with +61.

smsMessage.source = "SOURCE";
smsMessage.body = "MESSAGE";
smsMessage.to = "TO_PHONE_NUMBER";

Authorisation

Next, add your API credentials so you can use the ClickSend API in your project. In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API key. These can be found on your Dashboard here. This creates an instance of the SMSApi class, which passes your API credentials as parameters.

var smsApi = new api.SMSApi("USERNAME", "API_KEY");

Create an SMS message collection

Next, we’ll create a collection and add the smsMessage that you created earlier.

var smsMessage = new api.SmsMessage();
smsCollection.messages = [smsMessage];

Send SMS message

Finally, try to call the smsSendPost method. If everything works as expected then it will print the formatted response.

If an error occurs during the API call, the catch function will log the error message body. This structure helps you handle both successful API calls and potential errors that might occur during the process.

smsApi.smsSendPost(smsCollection)
.then(function(response) {
  console.log(response.body);
})
.catch(function(err) {
  console.error(err.body);
});

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

Dependencies

RestSharp - Version 106.11.7 or later
Json.NET - Version 12.0.3 or later
JsonSubTypes - Version 1.8.0 or later

The DLLs included in the package may not be the latest version. We recommend using NuGet to obtain the latest version of the packages:

Install-Package RestSharp
Install-Package Newtonsoft.Json
Install-Package JsonSubTypes
Install-Package System.Configuration.ConfigurationManager

Run the following command to generate the DLL, and include it (under the bin folder) in the C# project.

/bin/sh build.sh

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API Key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var configuration = new Configuration()
{
    Username = USERNAME,
    Password = API_KEY
};
var smsApi = new SMSApi(configuration);

var listOfSms = new List<SmsMessage>
{
    new SmsMessage(
        source: "SOURCE",
        body: "MESSAGE",
        to: "TO_PHONE_NUMBER"
    )
};

var smsCollection = new SmsMessageCollection(listOfSms);
var response = smsApi.SmsSendPost(smsCollection);

The code explained

Import namespaces

Prepare your environment to use the ClickSend API by importing the required namespaces.

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

Authorisation

Next, add your API credentials so you can use the ClickSend API in your project.

In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API Key. These can be found on your Dashboard here.

var configuration = new Configuration()
{
    Username = USERNAME,
    Password = API_KEY
};

Create an instance of the API class

The following snippet of code will create an instance of the SMSApi class, which is configured to work with the credentials that we set up in the previous step. This instance will be called in the following steps, allowing you to interact with ClickSend’s SMS-related functionality.

var smsApi = new SMSApi(configuration);

Configure your message

Now, it’s a simple matter of a few tweaks:

Replace SOURCE with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.
Replace MESSAGE with your own message.
Replace TO_PHONE_NUMBER with your own mobile number, including country code. For example, if you have an Australian number, it will start with +61.

var listOfSms = new List<SmsMessage>
{
    new SmsMessage(
        source: "SOURCE",
        body: "MESSAGE",
        to: "TO_PHONE_NUMBER"
    )
};

Create an SMS message collection

Next, we will create a collection using the SmsMessage object that we just configured as a parameter.

var smsCollection = new SmsMessageCollection(listOfSms);

Send SMS message

Finally, try to call the SmsSendPost method using the smsApi instance you created earlier.

var response = smsApi.SmsSendPost(smsCollection);

This guide is for the current version of the Go SDK.

Looking for v1? See our Quickstart guide for our Go v1 SDK.

Send your first SMS with the official ClickSend Go SDK in under 5 minutes.

1. Prerequisites

Before you start, make sure you have:

Requirement	Details
A ClickSend account	Sign up free if you don't have one. New accounts get free credit to test with.
API credentials	Your username and API key, both on the API Credentials page of the dashboard. You'll authenticate with these, not your dashboard login password.
Go 1.23 or newer	Check with `go version`.
Account credit	Sending SMS consumes credit. Free trial credit is enough for this guide; top up on the Billing page if you get an `INSUFFICIENT_CREDIT` error later.

2. Install

go get github.com/ClickSend/clicksend-go-v2/v6

3. Configure the client

The SDK authenticates with HTTP Basic auth, applied per-request via a context.Context carrying a BasicAuth value. Never hard-code real credentials — load them from environment variables:

export CLICKSEND_USERNAME="your-clicksend-username"
export CLICKSEND_API_KEY="your-clicksend-api-key"

package main

import (
    "context"
    "os"

    clicksend "github.com/ClickSend/clicksend-go-v2/v6"
)

func main() {
    cfg := clicksend.NewConfiguration()
    client := clicksend.NewAPIClient(cfg)

    auth := context.WithValue(context.Background(), clicksend.ContextBasicAuth, clicksend.BasicAuth{
        UserName: os.Getenv("CLICKSEND_USERNAME"), // placeholder: your ClickSend username
        Password: os.Getenv("CLICKSEND_API_KEY"),  // placeholder: your ClickSend API key
    })

    _ = auth
    _ = client
}

client is now an authenticated client for every ClickSend resource — each is a field on it (client.SmsAPI, client.MmsAPI, client.ManagementAPI, ...). Pass the same auth context to every call.

4. Send your first SMS

This is a complete, runnable example. Save it as send_sms.go, set the two environment variables from step 3, replace the to number with a real one, and run it.

package main

import (
    "context"
    "fmt"
    "os"

    clicksend "github.com/ClickSend/clicksend-go-v2/v6"
)

func main() {
    cfg := clicksend.NewConfiguration()
    client := clicksend.NewAPIClient(cfg)

    auth := context.WithValue(context.Background(), clicksend.ContextBasicAuth, clicksend.BasicAuth{
        UserName: os.Getenv("CLICKSEND_USERNAME"),
        Password: os.Getenv("CLICKSEND_API_KEY"),
    })

    message := clicksend.NewSendSmsRequestMessagesInnerWithDefaults()   message.SetFrom("YOUR_SENDER_ID") // placeholder: e.g. a ClickSend number, or omit to use your default sender
    message.SetBody("Hello from ClickSend!")
    message.SetTo("+61411111111") // placeholder: recipient in E.164 format

    sendSmsRequest := clicksend.NewSendSmsRequestWithDefaults()
    sendSmsRequest.SetMessages([]clicksend.SendSmsRequestMessagesInner{*message})

    result, httpResp, err := client.SmsAPI.SendSms(auth).SendSmsRequest(*sendSmsRequest).Execute()
    if err != nil {
        status := 0
        if httpResp != nil {
            status = httpResp.StatusCode
        }
        fmt.Printf("Failed to send SMS: %d %v\n", status, err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Run it:

go run send_sms.go

5. Understand the response

client.SmsAPI.SendSms(...).Execute() returns (*SendSms, *http.Response, error). Every model field is a pointer, so use the generated pointer-safe getters rather than dereferencing fields directly:

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Messages queued for delivery.",
  "data": {
    "total_price": 0.0388,
    "total_count": 1,
    "queued_count": 1,
    "blocked_count": 0,
    "messages": [
      {
        "to": "+61411111111",
        "body": "Hello from ClickSend!",
        "from": "SENDERID",
        "message_id": "6811A5CE-E374-5D26-82F5-1D9E52FA9AB3",
        "message_parts": 1,
        "message_price": "0.0388",
        "status": "SUCCESS",
        "date": 1758434400
      }
    ]
  }
}

The fields you'll use most:

Field	Where	Meaning
Message ID	`result.GetData().GetMessages()[0].GetMessageId()`	The unique ID for this message. Quote this when contacting support or looking up delivery receipts.
Status	`result.GetData().GetMessages()[0].GetStatus()`	The outcome for this specific message (`SUCCESS`, `INVALID_RECIPIENT`, ...). Check this per message — a batch send can succeed overall while individual messages fail (see §6).
Cost	`result.GetData().GetMessages()[0].GetMessagePrice()`	Cost of this one message (string). `result.GetData().GetTotalPrice()` is the sum across every message in the request.

message := result.GetData().GetMessages()[0]
fmt.Println("Message ID:", message.GetMessageId())
fmt.Println("Status:", message.GetStatus())
fmt.Println("Cost:", message.GetMessagePrice())

6. Common errors

client.SmsAPI.SendSms(...).Execute() returns a non-nil error on a non-2xx HTTP response — check it before touching result. But ClickSend also reports some failures — like an invalid recipient in an otherwise-valid batch — inside a 200 OK response, which won't produce an error at all. Always check each message's own GetStatus(), not just whether err is non-nil.

result, httpResp, err := client.SmsAPI.SendSms(auth).SendSmsRequest(*sendSmsRequest).Execute()
if err != nil {
    status := 0
    if httpResp != nil {
        status = httpResp.StatusCode
    }
    fmt.Printf("HTTP error: %d %v\n", status, err)
    return
}

// Even on HTTP 200, check each message's own status
for _, message := range result.GetData().GetMessages() {
    if message.GetStatus() != "SUCCESS" {
        fmt.Printf("Message to %s failed: %s\n", message.GetTo(), message.GetStatus())
    }
}

Error	How it shows up	What it means	Fix
Authentication failure	`err != nil`, `httpResp.StatusCode == 401` — the response body's `response_code` is `MISSING_CREDENTIALS` (no username/API key sent) or `INVALID_CREDENTIALS` (wrong username/API key).	Your `BasicAuth{UserName, Password}` doesn't match a valid ClickSend account, or an env var wasn't set.	Double-check `CLICKSEND_USERNAME`/`CLICKSEND_API_KEY` are set and copied exactly from the API Credentials page — use the API key, not your dashboard password.
Invalid recipient	Request usually still returns HTTP 200 (`response_code: SUCCESS` at the top level, `err` is `nil`) — the failure is on the individual message: `message.GetStatus()` is `INVALID_RECIPIENT`. This does not produce an error — you must check the status yourself.	The destination mobile number isn't a valid, deliverable number (bad format, wrong country, disconnected, etc).	Validate/normalize numbers to E.164 (e.g. `+61411111111`) before sending, and surface per-message status values to your own logs or users.
Insufficient balance	`response_code` (or a message's `GetStatus()`) is `INSUFFICIENT_CREDIT`, typically alongside `httpResp.StatusCode == 400` when it blocks the whole request.	Your account has run out of message credit.	Top up credit on the Billing page, or check balance first with `client.ManagementAPI.ViewAccountDetails(auth).Execute()`.

Next steps

Full endpoint reference: developers.clicksend.com/docs/rest/v3
Every other message type (MMS, voice, email, campaigns) and account/contact management: the package README
SDK source & issues: github.com/ClickSend/clicksend-go-v2

On this page, you will...

Sign up for a ClickSend account and get your API credentials.
Set up your development environment to work with our API.
Send your first SMS.

Before you start

You need a ClickSend account with credit to start sending. If you don’t have an account, create one here.
If you need to add more credit to your account, you can top up here. You’ll be credited $2 AUD free credit when you sign up.

Installation

Install via Cocoapods

CocoaPods is a dependency manager for Cocoa projects. For usage and installation instructions, visit their website.

To integrate ClickSendClient into your Xcode project using CocoaPods, specify it in your Podfile:

pod 'ClickSendClient', :git => 'https://github.com/ClickSend/clicksend-objc'

Send your first message

Below is the full snippet you can use to send an SMS. It includes placeholders that will need to be replaced when implementing the code in your project.

Placeholder	Replace with
`USERNAME`	Your ClickSend Username. Find it here.
`API_KEY`	Your ClickSend API key. Find it here.
`SOURCE`	The origin identifier for your API request, which could be the name of your application or the source location for the request.
`MESSAGE`	The content of your SMS message.
`TO_PHONE_NUMBER`	The phone number you're sending the message to, including the country code.

#import <ClickSendClient/CSApiClient.h>
#import <ClickSendClient/CSDefaultConfiguration.h>
#import <ClickSendClient/CSSMSApi.h>

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
[apiConfig setUsername:"USERNAME""];
[apiConfig setPassword:"API_KEY""];

CSApiClient *apiClient = [[CSApiClient alloc] initWithConfiguration:apiConfig];

CSSmsMessage *message = [[CSSmsMessage alloc] init];
message.source = "SOURCE";
message.body = "MESSAGE";
message.to = "TO_PHONE_NUMBER";

CSSmsMessageCollection *smsCollection = [[CSSmsMessageCollection alloc] init];
[smsCollection setMessages:(NSArray<CSSmsMessage> *)@[message]];

CSSMSApi *smsApi = [[CSSMSApi alloc] initWithApiClient:apiClient];
[smsApi smsSendPostWithSmsMessages:smsCollection completionHandler:^(NSString *output, NSError *error) {
    if (error != nil) {
        NSLog(@"Error %@", error.description);
    } else {
        NSLog(@"Output %@", output);
    }
}];

The code explained

Import modules

Prepare your environment to use the ClickSend API by importing the SDK and required modules.

#import <ClickSendClient/CSApiClient.h>
#import <ClickSendClient/CSDefaultConfiguration.h>
#import <ClickSendClient/CSSMSApi.h>

Authorisation

Next, add your API credentials so you can use the ClickSend API in your project.

In the following snippet, simply replace the USERNAME and API_KEY placeholders with your own Username and API key. These can be found in your Dashboard here.

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
[apiConfig setUsername:"USERNAME""];
[apiConfig setPassword:"API_KEY""];

Create an instance of the API class

The following snippet of code will create an instance of the CSApiClient class. This instance will be called in the following steps, allowing you to interact with ClickSend’s SMS functionality.

CSApiClient *apiClient = [[CSApiClient alloc] initWithConfiguration:apiConfig];

Configure your message

Now, it’s a simple matter of a few tweaks:

Replace SOURCE with your preferred source (eg. the name of your application). This is not seen by recipients, but will help you to identify messages sent from various applications.

Replace MESSAGE with your own message.

Replace TO_PHONE_NUMBER with your own mobile number, including country code. For example, if you have an Australian number, it will start with +61.

CSSmsMessage *message = [[CSSmsMessage alloc] init];
message.source = "SOURCE";
message.body = "MESSAGE";
message.to = "TO_PHONE_NUMBER";

Create an SMS message collection

Next, we’ll create a collection and add the CSSmsMessage that you created earlier.

CSSmsMessageCollection *smsCollection = [[CSSmsMessageCollection alloc] init];
[smsCollection setMessages:(NSArray<CSSmsMessage> *)@[message]];

Send SMS message

Finally, try to call the smsSendPostWithSmsMessages method using the smsCollection you created earlier. If everything works as expected then it will print the formatted response. If an exception occurs during the API call, the completion handler will log the outputted details. This structure helps you handle both successful API calls and potential errors that might occur during the process.

CSSMSApi *smsApi = [[CSSMSApi alloc] initWithApiClient:apiClient];
[smsApi smsSendPostWithSmsMessages:smsCollection completionHandler:^(NSString *output, NSError *error) {
    if (error != nil) {
        NSLog(@"Error %@", error.description);
    } else {
        NSLog(@"Output %@", output);
    }
}];

This guide is for the current version of the Python SDK.

Looking for v1? See our Quickstart guide for our Python v1 SDK.

Send your first SMS with the official ClickSend Python SDK in under 5 minutes.

1. Prerequisites

Before you start, make sure you have:

Requirement	Details
A ClickSend account	Sign up free if you don't have one. New accounts get free credit to test with.
API credentials	Your username and API key, both on the API Credentials page of the dashboard. You'll authenticate with these, not your dashboard login password.
Python 3.10 or newer	Check with `python3 --version`. (The repo's own build files disagree — `setup.py` requires 3.10+, `pyproject.toml` says 3.9+ — 3.10+ is the safer bound until that's reconciled.)
Account credit	Sending SMS consumes credit. Free trial credit is enough for this guide; top up on the Billing page if you get an `INSUFFICIENT_CREDIT` error later.

2. Install

pip install clicksend-client

3. Configure the client

The SDK authenticates with HTTP Basic auth, using a Configuration object built from your ClickSend username and API key, passed into an ApiClient. Never hard-code real credentials — load them from environment variables:

export CLICKSEND_USERNAME="your-clicksend-username"
export CLICKSEND_API_KEY="your-clicksend-api-key"

import os
import clicksend
from clicksend.api.sms_api import SmsApi

configuration = clicksend.Configuration(
    username=os.environ.get("CLICKSEND_USERNAME"),  # placeholder: your ClickSend username
    password=os.environ.get("CLICKSEND_API_KEY"),   # placeholder: your ClickSend API key
)

with clicksend.ApiClient(configuration) as api_client:
    sms_api = SmsApi(api_client)

sms_api is now an authenticated client for every SMS endpoint (send, history, templates, delivery receipts, etc.). Each ClickSend resource has its own API class (clicksend.api.mms_api.MmsApi, clicksend.api.management_api.ManagementApi, ...) — construct one per resource you need, reusing the same api_client.

4. Send your first SMS

This is a complete, runnable example. Save it as send_sms.py, set the two environment variables from step 3, replace the to number with a real one, and run it.

import os
import clicksend
from clicksend.api.sms_api import SmsApi
from clicksend.models.send_sms_request import SendSmsRequest
from clicksend.models.send_sms_request_messages_inner import SendSmsRequestMessagesInner
from clicksend.exceptions import ApiException

configuration = clicksend.Configuration(
    username=os.environ.get("CLICKSEND_USERNAME"),
    password=os.environ.get("CLICKSEND_API_KEY"),
)

with clicksend.ApiClient(configuration) as api_client:
    sms_api = SmsApi(api_client)

    message = SendSmsRequestMessagesInner(
        body="Hello from ClickSend!",
        to="+61411111111",         # placeholder: recipient in E.164 format
        **{"from": "YOUR_SENDER_ID"},  # placeholder: e.g. a ClickSend number, or omit to use your default sender
    )
    send_sms_request = SendSmsRequest(messages=[message])

    try:
        result = sms_api.send_sms(send_sms_request=send_sms_request)
        print(result)
    except ApiException as e:
        print(f"Failed to send SMS: {e.status} {e.body}")

Run it:

python3 send_sms.py

5. Understand the response

sms_api.send_sms(...) returns a SendSms object. Its attributes mirror the API's JSON response (native snake_case):

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Messages queued for delivery.",
  "data": {
    "total_price": 0.0388,
    "total_count": 1,
    "queued_count": 1,
    "blocked_count": 0,
    "messages": [
      {
        "to": "+61411111111",
        "body": "Hello from ClickSend!",
        "from": "SENDERID",
        "message_id": "6811A5CE-E374-5D26-82F5-1D9E52FA9AB3",
        "message_parts": 1,
        "message_price": "0.0388",
        "status": "SUCCESS",
        "date": 1758434400
      }
    ]
  }
}

The fields you'll use most:

Field	Where	Meaning
Message ID	`result.data.messages[0].message_id`	The unique ID for this message. Quote this when contacting support or looking up delivery receipts.
Status	`result.data.messages[0].status`	The outcome for this specific message (`SUCCESS`, `INVALID_RECIPIENT`, ...). Check this per message — a batch send can succeed overall while individual messages fail (see §6).
Cost	`result.data.messages[0].message_price`	Cost of this one message (string). `result.data.total_price` is the sum across every message in the request.

message = result.data.messages[0]
print("Message ID:", message.message_id)
print("Status:", message.status)
print("Cost:", message.message_price)

6. Common errors

sms_api.send_sms(...) raises an ApiException (or a status-specific subclass like UnauthorizedException) on a non-2xx HTTP response — catch it with try/except. But ClickSend also reports some failures — like an invalid recipient in an otherwise-valid batch — inside a 200 OK response, which won't raise at all. Always check each message's own status, not just whether the call raised.

Error	How it shows up	What it means	Fix
Authentication failure	`UnauthorizedException` (a subclass of `ApiException` with `.status == 401`) — raised, caught in `except`. `.body`'s `response_code` is `MISSING_CREDENTIALS` (no username/API key sent) or `INVALID_CREDENTIALS` (wrong username/API key).	Your `Configuration(username=..., password=...)` doesn't match a valid ClickSend account, or an env var wasn't set.	Double-check `CLICKSEND_USERNAME`/`CLICKSEND_API_KEY` are set and copied exactly from the API Credentials page — use the API key, not your dashboard password.
Invalid recipient	Request usually still returns HTTP 200 (`response_code: SUCCESS` at the top level) — the failure is on the individual message: `message.status` is `INVALID_RECIPIENT`. This does not raise — you must check the status yourself.	The destination mobile number isn't a valid, deliverable number (bad format, wrong country, disconnected, etc).	Validate/normalize numbers to E.164 (e.g. `+61411111111`) before sending, and surface per-message status values to your own logs or users.
Insufficient balance	`response_code` (or a message's `status`) is `INSUFFICIENT_CREDIT`, typically alongside a `BadRequestException` (`.status == 400`) when it blocks the whole request.	Your account has run out of message credit.	Top up credit on the Billing page, or check balance first with `ManagementApi(api_client).view_account_details()`.

Next steps

Full endpoint reference: developers.clicksend.com/docs/rest/v3
Every other message type (MMS, voice, email, campaigns) and account/contact management: the package README
SDK source & issues: github.com/ClickSend/clicksend-python-v2

Start sprinting with our API docs

Get all the detail you'll ever need in our full API docs. Learn how to launch your own features or integrate with others.

Full API Reference

SMS Quickstart

On this page:

Resources:

Resources:

Resources:

Resources:

Resources:

Resources:

Resources:

Resources:

Resources:

On this page, you will...

Before you start

Installation

Install via Cocoapods

Update Swift Version

Send your first message

The code explained

Import libraries

Authorisation

Configure your message

Create an SMS message collection

Send SMS message

On this page, you will...

Before you start

Installation

Full snippet

The code explained

Import functions

Authorisation

Create an instance of the API class

Configure your message

Send SMS message

On this page, you will...

Before you start

Installation

Send your first message

The code explained

Include files

Authorisation

Create an instance of the API class

Configure your message

Create an SMS message collection

Send SMS message

On this page, you will...

Before you start

Installation

Install via Github

Send your first message

The code: explained

Import functions

Authorisation and create an instance of the API class

Configure your message

Send SMS message

On this page, you will...

Before you start

Installation

Install Typescript

Compile TypeScript into JavaScript

Add the SDK to your project

Send your first message

The code explained

Import modules

Create an instance of the API class

Configure your message

Authorisation

Create an SMS message collection

Send SMS message

On this page, you will...

Before you start

Installation

Dependencies

Send your first message

The code explained

Import namespaces

Authorisation

Create an instance of the API class

Configure your message

Create an SMS message collection

Send SMS message