const { Infobip, AuthType } = require(‘@infobip-api/sdk’);
const infobip = new Infobip({
  baseUrl: ‘{baseUrl}’,
  apiKey: ‘{authorization}’,
  authType: AuthType.ApiKey,
});
infobip.channels.sms.send({
  messages: [{
    destinations: [{
      to: “41793026727”
    }],
    from: “InfoSMS”,
    text: “This is a sample message”,
  }]
});
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
									
					
	

		from infobip_channels.sms.channel import SMSChannel

def main():
    channel = SMSChannel.from_env()

    message = {
        “messages”: [
            {
                “destinations”: [
                    {
                        “to”: “41793026727”
                    }
                ],
                “from”: “InfoSMS”,
                “text”: “This is a sample message”
            }
        ]
    }

    response = channel.send_sms_message(message)

    print(response)
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
									
					
	

		package main

import (
    “context”
    “fmt”
    “github.com/infobip-community/infobip-api-go-sdk/v3/pkg/infobip”
    “github.com/infobip-community/infobip-api-go-sdk/v3/pkg/infobip/models”
)

func main() {
    baseURL := “your-base-URL”
    apiKey := “your-api-key”

    client, _ := infobip.NewClient(baseURL, apiKey)

    msg := models.SMSMsg{
        Destinations: []models.SMSDestination{
            {To: “41793026727”},
        },
        From: “InfoSMS”,
        Text: “Hello from Infobip Go SDK!”,
    }

    req := models.SendSMSRequest{
        Messages: []models.SMSMsg{msg},
    }

    resp, respDetails, _ := client.SMS.Send(context.Background(), req)

    fmt.Printf(“Sent message: %+v\n”, resp)
    fmt.Printf(“HTTP response: %d\n”, respDetails.HTTPResponse.StatusCode)
}
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
											26
											27
											28
											29
											30
											31
											32
									
					
	

		use infobip_sdk::api::sms::SmsClient;
use infobip_sdk::configuration::{ApiKey, Configuration};
use infobip_sdk::model::sms::{Destination, Message, SendRequestBody};

#[tokio::main]
async fn main() {
    let config = Configuration::with_api_key(
        “<your-base-url>”.into(),
        ApiKey::new(“your-api-key”.into()),
    );
    let sms_client = SmsClient::with_configuration(config);

    let mut message = Message::new(vec![Destination::new(“41793026727”)]);
    message.text = Some(“Hello from Infobip API Rust SDK!”.into());
    message.from = Some(“InfoSMS”.into());

    let request_body = SendRequestBody::new(vec![message]);

    let response = sms_client.send(request_body).await.unwrap();

    println!(“{:?}”, response)
}
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
									
					
	

		require “uri”
 require “json”
 require “net/http”
 url = URI(“https://{baseUrl}/sms/2/text/advanced”)
 https = Net::HTTP.new(url.host, url.port)
 https.use_ssl = true
 request = Net::HTTP::Post.new(url)
 request[“Authorization”] = “{authorization}”
 request[“Content-Type”] = “application/json”
 request[“Accept”] = “application/json”
 request.body = JSON.dump({
     “messages”: [
         {
             “destinations”: [
                 {
                     “to”: “41793026727”
                 }
             ],
             “from”: “InfoSMS”,
             “text”: “This is a sample message”
         }
     ]
 })
 response = https.request(request)
 puts response.read_body
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10
											11
											12
											13
											14
											15
											16
											17
											18
											19
											20
											21
											22
											23
											24
											25
									
					
	

		var client = new RestClient(“https://{baseUrl}/sms/2/text/advanced”);
 client.Timeout = -1;
 var request = new RestRequest(Method.POST);
 request.AddHeader(“Authorization”, “{authorization}”);
 request.AddHeader(“Content-Type”, “application/json”);
 request.AddHeader(“Accept”, “application/json”);
 var body = @”{“”messages””:[{“”destinations””:[{“”to””:””41793026727″”}],””from””:””InfoSMS””,””text””:””This is a sample message””}]}”;
 request.AddParameter(“application/json”, body,  ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 Console.WriteLine(response.Content);
							
											1
											2
											3
											4
											5
											6
											7
											8
											9
											10