NAV
shell php smsapi-php-client smsapi-python-client smsapi-java-client
  • Dokumentacja SMS API - 1. Wprowadzenie
  • 2. Pojedynczy SMS
  • 3. Masowe wysyłanie SMSów
  • 4. Wykorzystanie szablonów
  • 5. mail2SMS
  • 6. Sprawdzenie ilości punktów
  • 7. Wiadomości MMS
  • 8. Wiadomości VMS
  • 9. Raporty Callback
  • 10. Odbiory Wiadomości
  • 11. HLR
  • 12. Baza Kontaktów
  • 13. Czarna Lista
  • 14. Konto użytkownika
  • 15. Pola nadawcy
  • 16. SMS Authenticator
  • 17. Interfejs SMPP
  • 18. Lista statusów doręczenia
  • 19. Kody błędów
  • 20. Alfabet 7bit GSM
  • 21. Kodowanie
  • 22. Integracje
  • Dokumentacja SMS API - 1. Wprowadzenie

    Platforma SMSAPI została skierowana do użytkowników chcących rozbudować swoje aplikacje o system wysyłania i odbierania SMS-ów oraz MMS-ów oraz wysyłki wiadomości głosowych VMS. Aplikacja ta w prosty sposób umożliwia integrację dowolnego serwisu z bramką SMS, MMS i/lub VMS. Głównymi atutami naszego serwisu oprócz prostej implementacji jest możliwość nadawania wiadomości z własnej nazwy (maksymalnie 11 znaków). Każdy wysłany SMS, MMS oraz VMS za pośrednictwem systemu posiada unikalny numer identyfikacyjny pozwalając na sprawdzenie raportu doręczenia wiadomości.

    Rozpoczęcie współpracy

    W celu rozpoczęcia współpracy należy utworzyć konto w serwisie SMSAPI. Utworzone konto jest gotowe do użytku, jednak zalecamy ustawienie własnego pola nadawcy. Jako domyślne ustawione jest pole nadawcy „Test”. Dodanie pola nadawcy jest usługą całkowicie darmową.

    Filtr IP dla interfejsu API

    W celu dodatkowego zabezpieczenie interfejsu API w Filtr adresów IP ustawić można adresy IP z których możliwa będzie wysyłka wiadomości (w przypadku próby dokonania wysyłki z innego IP system zwróci błąd: ERROR:105 ). Adresy należy oddzielić przecinkami.

    Autoryzacja

    Przykład:

    POST /sms.do HTTP/1.1
    Host: https://api.smsapi.pl/
    Authorization: Bearer token_api_oauth
    

    Rekomendujemy autoryzację OAuth 2.0. Generowanie tokenu z dostępem do wybranych stref można zrealizować w naszym panelu klienta Tokeny API.

    W odwołaniu do API wymagany jest dodatkowy nagłówek autoryzacyjny.

    Jeżeli wykorzystywane środowisko nie pozwala na modyfikację nagłówków opcjonalnie można dodać parametr access_token w którym zostanie przekazany token. Jest to jednak rozwiązanie nierekomendowane oraz obniżające poziom bezpieczeństwa.

    Adresy URL

    Adresy URL do połączenia z aplikacją - zwane dalej "Adresem połączenia":

    Biblioteki

    Wykorzystanie gotowych bibliotek SMSAPI pozwala na przyśpieszenie oraz uproszczenie prac związanych z integracją z naszą platformą. Wszystkie dostępne biblioteki są dostępne na GitHub.

    Język programowania Github link:
    PHP Biblioteka PHP
    C# .net Biblioteka C#
    Bash Biblioteka Bash
    Python Biblioteka Python
    JavaScript (node.js) Biblioteka JavaScript (node.js)
    Java Biblioteka Java
    Go Biblioteka Go

    Dokumentacja openAPI

    Poza endpointami wspomnianymi w tej dokumentacji, SMSAPI udostępnia też inne zasoby API do realizacji wielu zadań związanych z kontem. Są one udokumentowane w oparciu o standard openAPI tutaj oraz na bieżąco rozwijane i aktualizowane.

    2. Pojedynczy SMS

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500000000&\
    message=treść_wiadomości&\
    format=json"
    
    <?php
    
    function sms_send($params, $token, $backup = false)
    {
        static $content;
    
        if ($backup == true) {
            $url = 'https://api2.smsapi.pl/sms.do';
        } else {
            $url = 'https://api.smsapi.pl/sms.do';
        }
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, $params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
        $http_status = curl_getinfo($c, CURLINFO_HTTP_CODE);
    
        if ($http_status != 200 && $backup == false) {
            $backup = true;
            sms_send($params, $token, $backup);
        }
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = array(
        'to' => '500000000', //numery odbiorców rozdzielone przecinkami
        'from' => 'Test', //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'message' => "Hello world!", //treść wiadomości
        'format' => 'json'
    );
    
    echo sms_send($params, $token);
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmsBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSms(SendSmsBag::withMessage('48500000000', 'Hello world!'));
    
    var_dump($sms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000", message="treść wiadomości", from_="Pole Nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSms {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                SMSSend action = smsApi.actionSend("000000000", "test message");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

    
    {
        "count":1,
        "list": [
        {
            "id":"1460969715572091219",       //id wiadomości
            "points":0.16,                    //cena wiadomości
            "number":"44123456789",           //numer odbiorczy z prefixem
            "date_sent":1460969712,           //data wysyłki
            "submitted_number":"44123456789", //numer odbiorczy podany w zapytaniu
            "status":"QUEUE"                  //status wiadomości
        }
      ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
    "invalid_numbers":[
        {
          "number":"44123456789",               //numer odbiorczy z prefixem
          "submitted_number":"44123456789",     //numer odbiorczy podany w zapytaniu
          "message":"Invalid phone number"      //opis błędu
        }
      ],
      "error":13,                               //kod błędu
      "message":"No correct phone numbers"      //opis błędu
    }
    
    

    Przykładowa odpowiedź (tekst):

    a) w przypadku sukcesu:

    OK:<ID>:<POINTS>
    OK:1460969715572091219:0.16
    
    

    b) w przypadku niepowodzenia:

    ERROR:<ERR>
    ERROR:13
    
    Parametr Opis
    to Numer odbiorcy wiadomości w formacie 48xxxxxxxxx lub xxxxxxxxx. Np. 48505602702 lub 505602702.
    group Nazwa grupy kontaktów z książki telefonicznej, do których ma zostać wysłana wiadomość
    message Treść wiadomości. Standardowo do 160 znaków lub 70 znaków w przypadku wystąpienia chociaż jednego znaku specjalnego (polskie znaki uważane są za specjalne). Maksymalna długość wiadomości wynosi 1530 znaków (lub 670 ze znakami specjalnymi) i jest wysyłana/ jako 10 połączonych SMS-ów, obciążając konto zgodnie z aktualnym cennikiem
    from Parametr from definiuje rodzaj wysłanej wiadomości (Pro / 2way) jednocześnie dla wiadomości Pro określając Pole Nadawcy z jakim wiadomość ma być wysłana: &from=Nazwa – spowoduje wysłanie wiadomości Pro z polem nadawcy „Nazwa” &from=2way – spowoduje wysłanie wiadomości typu 2way. Pozostawienie pola pustego powoduje wysłanie domyślnego rodzaju wiadomości z domyślnym polem nadawcy. Przyjmowane są tylko nazwy zweryfikowane. (&from=aktywna_nazwa). Pole nadawcy należy dodać po zalogowaniu na stronie SMSAPI, Pola Nadawcy.
    encoding Parametr określa kodowanie polskich znaków w SMS-ie. Domyślne kodowanie jest windows-1250. Jeżeli występuje konieczność zmiany kodowania, należy użyć parametru encoding z danymi: Interfejs HTTP/S API - wersja 2.34-dla iso-8859-2 (latin2) – należy podać wartość „iso-8859-2”,-dla utf-8 – należy podać wartość „utf-8”.
    flash Wysyłanie wiadomości trybem „flash”, odbywa się poprzez podanie parametru flash o wartości „1”. SMS-y flash są automatycznie wyświetlane na ekranie głównym telefonu komórkowego i nie są przechowywane w skrzynce odbiorczej (jeśli nie zostaną zapisane).
    test Wiadomość nie jest wysyłana, wyświetlana jest jedynie odpowiedź (w celach testowych). (&test=1)
    details W odpowiedzi zawarte jest więcej szczegółów. (Treść wiadomości, długość wiadomość, ilość części z jakich składa się wiadomość). (&details=1)
    date Data w formacie unixtime (&date=1287734110) lub ISO 8601 (&date=2012-05-10T08:40:27+00:00). Określa kiedy wiadomość ma być wysłana. W przypadku wstawienia daty przeszłej wiadomość zostanie wysłana od razu. Wiadomość można zaplanować na maksymalnie 3 miesiące do przodu.
    date_validate Ustawienie „1” sprawdza poprawność formatu podanej daty. W przypadku wystąpienia błędnej daty zwrócony zostanie błąd ERROR:54
    time_restriction Ustala zachowanie podczas próby wysyłki w godzinach/datach nie odpowiadających ustawieniom na koncie. Dostępne wartości to follow- działaj według ustawień, ignore - ignoruj ustawienia oraz nearest_available- zaplanuj wysyłkę w najbliższym dozwolonym czasie.
    skip_foreign Ustawienie tego parametru (&skip_foreign=1) powoduje pominięcie numerów nie-polskich jeżeli takie pojawią się w odwołaniu
    allow_duplicates Pozwala na wysłanie wiadomości na numery zduplikowane w danym odwołaniu (przydatne np. przy wykorzystywaniu sparametryzowanych treści)
    idx Opcjonalny parametr użytkownika wysyłany z wiadomością a następnie zwracany przy wywołaniu zwrotnym CALLBACK. Parametr idx może mieć maksymalnie 255 znaków dopuszczalne są cyfry 0 - 9 oraz litery a – z (wielkość liter nie jest rozróżniana). (&idx=123)
    check_idx Pozwala zabezpieczyć przed wysłaniem dwóch wiadomości z identyczną wartością parametru idx w trakcie ostatnich 24h. W przypadku ustawienia parametru (&check_idx=1) system sprawdza czy wiadomość z podanym idx nie została wysłana w ostatnich 24h lub czy nie jest zaplanowana do wysłania w przyszłości, jeżeli jest zwracany jest błąd 53.
    nounicode Ustawienie 1 zabezpiecza przed wysłaniem wiadomości ze znakami specjalnymi (w tym polskimi) (ERROR:11).
    normalize Opcja spowoduje zastąpienie w wiadomości SMS znaków specjalnych na ich odpowiedniki (np. ą-a, ć-c, ę-e...). (&normalize=1)
    fast Ustawienie 1 spowoduje wysłanie wiadomości przy wykorzystaniu osobnego kanału zapewniającego szybkie doręczenie wiadomości Fast. Z parametru korzystać można podczas wysyłania wiadomości Pro, Ilość punktów za wysyłkę pomnożona będzie przez 1.5 Uwaga! Dla tego parametru zabronione jest prowadzenie wysyłek masowych i marketingowych.
    partner_id Kod partnerski, który otrzymać można po podpisaniu umowy partnerskiej. Kod nie będzie brany pod uwagę jeżeli użytkownik wysyłający polecony jest przez innego klienta lub podaje swój kod.
    max_parts Parametr określa maksymalną ilość części z jakich może składać się wiadomość. Maksymalna wartość to 10. W przypadku gdy wiadomość składa się z większej ilości części zwrócony zostanie błąd ERROR:12 Domyślna ilość części ustawiana jest w panelu klienta.
    expiration_date Różnica pomiędzy datą wysyłki a datą wygaśnięcia musi być większa niż 15 minut i mniejsza niż 72 godzin (zaleca się aby było to minimum 1 godzina i maksymalnie 12 godzin).Data może zostać podana w formacie unixtime (&date=1287734110) lub ISO 8601 (&date=2012-05-10T08:40:27+00:00).
    discount_group Nazwa grupy kodów rabatowych do załączenia w wysyłce. Grupy można dodawać oraz edytować w panelu klienta.
    notify_url Parametr pozwalający na ustawienie adresu URL do skryptu callback odbierającego raporty doręczenia dla danej wiadomości. Adres ten jest brany w pierwszej kolejności (przed globalnym adresem ustawionym na koncie).
    fallback Opcjonalny parametr pozwalający na zastąpienie SMS-a wysyłką VMS w przypadku wysyłki na numer stacjonarny. Należy podać go w postaci jednoelementowej tablicy "type":"vms". Parametr jest dostępny tylko dla pojedynczej wysyłki.
    format Dla &format=json powoduje, że zwrotka z API wysyłana jest w formacie JSON.


    Odpowiedź w przypadku powodzenia:

    Odpowiedź OK Opis
    id ID wiadomości w serwisie SMSAPI
    points Ilość punktów pobrana za wysyłkę wiadomości SMS konta SMSAPI
    number Numer telefonu na który została zlecona wysyłka wiadomości SMS w formacie kod_kraju+numer, np. 48500000000
    date_sent Data wysyłki wiadomości SMS
    submitted_number Numer telefonu w formacie przekazanym w odwołaniu do API, np. +48500000000,0048500000000
    status Status doręczenia wiadomości SMS. Pełna lista obsługiwanych statusów

    Odpowiedź w przypadku niepowodzenia:

    Odpowiedź ERROR Opis
    ERROR Kod Błędu

    Wiadomość FAST

    
    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=44123456789&\
    message=tresc_wiadomosci&\
    fast=1&\
    format=json"
    
    
    <?php
    
    $params = array(
        'to'       => '48500000000',                //numer odbiorczy  
        'from'     => 'Test',                      //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'message'  => 'treść wiadomości',            //treść wiadomości
        'fast'     => '1',
        'format'   => 'json'
    );
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmsBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $sendSmsBag = SendSmsBag::withMessage('48500000000', 'Hello world!');
    $sendSmsBag->fast = true;
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSms($sendSmsBag);
    
    var_dump($sms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send_fast(to="48500000000", message="treść wiadomości", from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmsFast {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                SMSSend action = smsApi.actionSend("000000000", "test message");
                action.setFast(true);
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

    
    {
      "count":1,
      "list": [
        {
          "id":"1460969715572091219",       //id wiadomości
          "points":0.70,                    //cena wiadomości
          "number":"44123456789",           //numer odbiorczy z prefixem
          "date_sent":1460969712,           //data wysyłki
          "submitted_number":"44123456789", //numer odbiorczy podany w zapytaniu
          "status":"QUEUE"                  //status wiadomości
        }
      ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
      "invalid_numbers":[
        {
          "number":"44123456789",               //numer odbiorczy z prefixem
          "submitted_number":"44123456789",     //numer odbiorczy podany w zapytaniu
          "message":"Invalid phone number"      //opis błędu
        }
      ],
      "error":13,                               //kod błędu
      "message":"No correct phone numbers"      //opis błędu
    }
    
    

    Przykładowa odpowiedź (tekst):

    a) w przypadku sukcesu:

    OK:<ID>:<POINTS>
    OK:17101000090360359:0.70
    

    b) w przypadku niepowodzenia:

    ERROR:<ERR>
    ERROR:13
    
    ID Unikalne ID wiadomości
    POINTS Ilośc punktów wykorzystanych do wysyłki
    ERR Kod błędu (sprawdź Kody błędów)

    Ustawienie parametru fast=1 spowoduje wysłanie wiadomości przy wykorzystaniu osobnego kanału zapewniającego najwyższy priorytet wysyłki. Z parametru korzystać można podczas wysyłania wiadomości Pro, Ilość punktów za wysyłkę pomnożona będzie przez 1.5

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    Planowanie SMS

    
    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=44123456789&\
    message=tresc_wiadomosci&\
    date=1577878200&\
    format=json"
    
    
    
    <?php
    
    $params = array(
        'to'       => '48500000000',            //numer odbiorczy  
        'from'     => 'Test',                   //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames 
        'message'  => 'treść wiadomości',        //treść wiadomości
        'date'     => '1577878200',             //data wysyłki UNIXTIME / ISO 8601
        'format'   => 'json'
    );
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\ScheduleSmsBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->scheduleSms(ScheduleSmsBag::withMessage(new DateTime(), '48500000000', 'Hello world!'));
    
    var_dump($sms);
    
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000", message="treść wiadomości", date="1577878200",  from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    

    W celu wysłania wiadomości o określonej godzinie/dacie musi zostać użyty parametr date, dopuszczalne formaty daty to unixtime i ISO 8601.

    Usuwanie zaplanowanej wiadomości:

    W celu usunięcia zaplanowanej wiadomości należy w parametrze sch_del podać id wysyłki która ma zostać usunięta. Aby usunąć więcej niż jedną wysyłkę należy podać ID rozdzielone przecinkami.

    
    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    sch_del=09040616088106874&\
    format=json"
    
    
    <?php
    
    $params = array(
        'sch_del'  => '9040616088106874',   //id wysyłki
        'format'   => 'json'
    );
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\ScheduleSmsBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->deleteScheduledSms(new DeleteScheduledSmssBag(['id1', 'id2']));
    
    var_dump($sms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.remove_scheduled(id='ID_zaplanowanej_wiadomości')
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSDelete;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class DeleteSmsScheduled {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                SMSDelete action = smsApi.actionDelete("id1");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    3. Masowe wysyłanie SMSów

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500500500,48501501501,48502502502&\
    message=tresc_wiadomosci&\
    format=json"
    
    
    <?php
    
    $params = array(
        'to'       => '48500500500,48501501501,48502502502',     //numery odbiorcze  
        'from'     => 'Test',                                    //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'message'  => 'treść wiadomości',                         //treść wiadomości
        'format'   => 'json'
    );
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss(SendSmssBag::withMessage(['48500000000', '48500000001'], 'Hello world!'));
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000,48500000001,48500000002", message="treść wiadomości",  from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmss {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                SMSSend action = smsApi.actionSend(to, "test message");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

        {
            "count": 3,
            "list": [
                {
                    "id":"1460978572913968440",
                    "points":0.16,
                    "number":"48500500500",
                    "date_sent":1460978579,
                    "submitted_number":"48500500500",
                    "status":"QUEUE"
                },
                {
                    "id":"1460978572913968450",
                    "points":0.16,
                    "number":"48501501501",
                    "date_sent":1460978579,
                    "submitted_number":"48501501501",
                    "status":"QUEUE"
                },
                {
                    "id":"1460978572913968460",
                    "points":0.16,
                    "number":"48502502502",
                    "date_sent":1460978579,
                    "submitted_number":"48502502502",
                    "status":"QUEUE"
                }
    
            ]
        }
    

    b) w przypadku niepowodzenia:

        {
            "invalid_numbers": [
                {
                    "number":"456456456",
                    "submitted_number":"456456456",
                    "message":"Invalid phone number"
                },
                {
                    "number":"321321321",
                    "submitted_number":"321321321",
                    "message":"Invalid phone number"
                }
            ],
            "error":13,
            "message":"No correct phone numbers"
        }
    
    

    Przykładowa odpowiedź (tekst):

    a) w przypadku sukcesu:

    OK:<ID>:<POINTS>
    OK:1460978572913968440:0.16:500500500;OK:1460978572913968450:0.16:501500501;OK:1460978572913968460:0.16:501500502
    
    

    b) w przypadku niepowodzenia:

    ERROR:<ERR>
    ERROR:13
    

    Wysyłanie SMS-ów do grupy odbiorców odbywa się tak jak do pojedynczego odbiorcy (opis w punkcie 2) lecz z podaniem wielu numerów telefonów w parametrze to. Dodatkowo cała wysyłka powinna odbywać się metodą POST do adresu połączenia.

    Jeżeli cena za wysłanie wszystkich SMS-ów jest większa od ilości punktów dostępnych w serwisie, zostanie zwrócony komunikat o błędzie (103) i SMS-y nie zostaną wysłane. Jeżeli zostały podane błędne numery (nierozpoznane przez serwis SMSAPI ze względu na błędny prefiks), wszystkie SMS-y zostaną wysłane z pominięciem tych numerów, wówczas ilość otrzymanych raportów będzie różnić się od ilości wysłanych SMS-ów. Sytuacja ta nie dotyczy numerów z poprawnym prefiksem (np. 500000000), gdzie SMS zostanie wysłany, a następnie odrzucony gdyż numer nie istnieje (punkty za wysłanie SMS-a zostaną pobrane). Numery, które się powtarzają zostaną wysłane tylko 1 raz.

    Warto zauważyć, że przy wysyłce SMS-ów do grupy odbiorców dodatkowo zwracany jest numer telefonu oraz każdy SMS jest zakończany średnikiem (oprócz ostatniego. Nie dotyczy wysyłki z parametrem &format=json).

    Zalecana maksymalna ilość jednorazowej wysyłki (jedno wywołanie) wynosi 10 000 wiadomości.

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    SMS do grupy z bazy kontaktów

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    group=grupa_testowa&\
    message=treść_z_parametrami_[%imie%]&\
    format=json"
    
    <?php
    
    $params = array(
        'group'    => 'grupa_testowa',                  //grupa odbiorców  
        'from'     => 'Test',                           //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames 
        'message'  => 'treść z parametrami [%imie%]', //treść wiadomości
        'format'   => 'json'
    );
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmsToGroupBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmsToGroup(SendSmsToGroupBag::withMessage('Contacts group name', 'Hello [%imie_w%]!'));
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send_to_group(group="Nazwa Grupy", message="treść wiadomości", from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

        {
            "count": 3,
            "list": [
                {
                    "id":"1460978572913968440",
                    "points":0.16,
                    "number":"48500500500",
                    "date_sent":1460978579,
                    "submitted_number":"48500500500",
                    "status":"QUEUE"
                },
                {
                    "id":"1460978572913968450",
                    "points":0.16,
                    "number":"48501501501",
                    "date_sent":1460978579,
                    "submitted_number":"48501501501",
                    "status":"QUEUE"
                },
                {
                    "id":"1460978572913968460",
                    "points":0.16,
                    "number":"48502502502",
                    "date_sent":1460978579,
                    "submitted_number":"48502502502",
                    "status":"QUEUE"
                }
    
            ]
        }
    

    b) w przypadku niepowodzenia:

        {
            "invalid_numbers": [
                {
                    "number":"456456456",
                    "submitted_number":"456456456",
                    "message":"Invalid phone number"
                },
                {
                    "number":"321321321",
                    "submitted_number":"321321321",
                    "message":"Invalid phone number"
                }
            ],
            "error":13,
            "message":"No correct phone numbers"
        }
    
    

    Przykładowa odpowiedź (tekst):

    a) w przypadku sukcesu:

    OK:<ID>:<POINTS>
    OK:1460978572913968440:0.16:500500500;OK:1460978572913968450:0.16:501500501;OK:1460978572913968460:0.16:501500502
    
    

    b) w przypadku niepowodzenia:

    ERROR:<ERR>
    ERROR:13
    

    W celu wysłania wiadomości do określonej grupy należy w pierwszej kolejności stworzyć ją w panelu WWW Grupy.

    Istnieje możliwość wstawienia pola własnego do treści wiadomości. Pola własne mogą być definiowane w panelu WWW Pola własne. Aby wstawić pole, w treści wiadomości należy wpisać [%kontakt.nazwa pola%]. Podczas wysyłki pole zostanie zastąpione odpowiednią wartością przypisaną do danego kontaktu. Istnieje także możliwość użycia standardowych pól, takich jak:

    Parametr Opis
    [%imie%] Imię przypisane do kontaktu
    [%imie_w%] Wołacz imienia przypisanego do kontaktu
    [%nazwisko%] Nazwisko przypisane do kontaktu
    [%kontakt.kraj%] Kraj
    [%kontakt.informacja%] Opis kontaktu
    [%kontakt.email%] Email
    [%kontakt.urzadzenie%] Urządzenie użytkownika (przypisywany automatycznie w przypadku kliknięcia odbiorcy w skrócony link)
    [%kontakt.miasto%] Miejscowość
    [%kontakt.przegladarka%] Przeglądarka (przypisywana automatycznie w przypadku kliknięcia odbiorcy w skrócony link)
    [%kontakt.system_operacyjny%] System operacyjny użytkownika (przypisywany automatycznie w przypadku kliknięcia odbiorcy w skrócony link)
    [%kontakt.nazwa_pola%] Niestandardowe pole własne

    Wykorzystanie parametrów

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48600111222,48500111222&\
    message=test_wiadomości_parametr1:[%1%]_parametr2:[%2%]&\
    param1=Jan|Ania&\
    param2=30|40&\
    format=json"
    
    <?php
    
    $params = array(
        'to'       => '8600111222,48500111222',                             //numery odbiorców
        'from'     => 'Test',                                               //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'message'  => 'test wiadomości, parametr1:[%1%] parametr2:[%2%]',  //treść wiadomości
        'param1'   => 'Jan|Ania',
        'param2'   => '30|40',
        'format'   => 'json'
    );
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $sendSmssBag = SendSmssBag::withMessage(['48500000000', '48500000000'], '[%1%] [%2%]!')
        ->setParams([1 => ['Hello', 'Witaj'], 2 => ['world', 'świecie']]);
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss($sendSmssBag);
    
    var_dump($sms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to=['48500000000', '48500000001'], message='test wiadomości, parametr1:[%1%] parametr2:[%2%]', param1=['Jan', 'Ania'], param2=['30', '40'], from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmssWithParams {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                String[] param1 = {"Hello", "Witaj"};
                String[] param2 = {"world", "świecie"};
                SMSSend action = smsApi.actionSend(to, "[%1%] [%2%]");
                action.setParam(1, param1);
                action.setParam(2, param2);
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Wiadomości będą miały następującą treść:

    Wiadomość 1: Test wiadomosci, parametr1: Jan parametr2: 30
    Wiadomość 2: Test wiadomosci, parametr1: Ania parametr2: 40
    

    Istnieje możliwość wysłania do 100 spersonalizowanych wiadomości przy pomocy jednego wywołania wykorzystując parametry. W razie potrzeby wysłania większej ilości wiadomości można wywołać równolegle kilka odwołań.Parametry powinny być zdefiniowane w wywołaniu jako param1, param2, param3, param4, które zastępowały będą [%1%], [%2%], [%3%] oraz [%4%] w treści wiadomości. Wartości parametrów muszą być oddzielone znakiem pipe „|” według wzoru:

    param1=Ania|Michal|Andrzej&param2=Nowak|Kowalski|Nowakowski

    Liczba parametrów musi być identyczna z liczbą numerów do których wysłane mają być wiadomości w innym przypadku zwrócony będzie błąd: ERROR:18 i wiadomość nie zostanie wysłana.

    Jeżeli jeden z numerów będzie błędny zostanie on pominięty i wiadomości zostaną wysłane z pominięciem tego numeru.

    Parametry

    Parametry wykorzystane mogą być po zdefiniowaniu ich miejsca w wiadomości:

    Parametr Opis
    [%1%] Tekst parametru 1 (param1)
    [%2%] Tekst parametru 2 (param2)
    [%3%] Tekst parametru 3 (param3)
    [%4%] Tekst parametru 4 (param4)

    Parametry IDX

    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $sendSmssBag = SendSmssBag::withMessage(['48500000000', '48500000001'], 'Hello world!');
    $sendSmssBag->idx = ['id-1', 'id-2'];
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss($sendSmssBag);
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to=['48500000000', '48500000001'], message='treść wiadomości', idx=['idx1', 'idx2'], from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmssWithIdx {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                String[] idx = {"id-1", "id-2"};
                SMSSend action = smsApi.actionSend(to, "test message");
                action.setIDx(idx);
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Istnieje możliwość wysyłania masowych wiadomości z parametrem użytkownika IDX różnym dla każdej wiadomości. Parametr ten zwracany jest w wywołaniu zwrotnym CALLBACK z raportem doręczenia. Parametr IDX może mieć dowolną wartość, może on być wykorzystywany np. jako flaga użytkownika lub wewnętrzne ID z systemu klienckiego. Dodatkowo przy użyciu parametru IDX możliwe jest użycie parametry check_idx (&check_idx=1), użycie tego parametru nie pozwoli na wysłanie więcej niż jednej wiadomości z tym samym parametrem IDX w trakcie ostatnich 24h. W przypadku próby wysłania wiadomości z wartością parametru IDX która już pojawiła się dla danego użytkownika zostanie zwrócony błąd ERROR: 53. W celu przypisania różnych parametrów rożnym wiadomością należy oddzielić je znakiem “pipe” co przedstawia poniższy przykład:

    idx=idx1|idx2|idx3|idx4

    Liczba parametrów IDX musi być identyczna z liczbą wysyłanych wiadomości

    Kody rabatowe

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48600111222,48500111222&\
    discount_group=kody&\
    message=Test_wiadomości_z_kodem_rabatowym_[%kod%]&\
    format=json"
    
    <?php
    $params = array(
        'discount_group' => 'kody',                                  //grupa kodów
        'to'             => '48500500500,48501501501,48502502502',   //grupa odbiorców  
        'from'           => 'Test',                                  //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames 
        'message'        => 'treść z kodem rabatowym [%kod%]',         //treść wiadomości
        'format'         => 'json'
    );
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss(SendSmssBag::withMessage(['48500000000', '48500000001'], 'Hello world! Discount code: [%kod%]'));
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000,48500000001,48500000002", message="treść wiadomości kod rabatowy: [%kod%]", from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmssWithDiscountCode {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                SMSSend action = smsApi.actionSend(to, "Hello world! Discount code: [%code%]");
                action.setDiscountGroup("codes");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    SMSAPI umożliwia wysyłanie wiadomości z kodami rabatowymi. Aby wysyłać takie wiadomości trzeba najpierw przygotować listę kodów rabatowych w panelu klienta Kody rabatowe. Kody rabatowe mogą być wczytane z uprzednio przygotowanego pliku csv lub skorzystać z wbudowanego generatora kodów.

    Podczas wysyłki system pobiera kody z podanej listy jednocześnie oznaczając je jako wykorzystane (jeden kod może być wykorzystany tylko raz). Aby móc wykorzystać grupę kodów do wysyłki musi być ona aktywna (data ważności nie minęła) oraz zawierać odpowiednią liczbę kodów

    Wiadomości z idz.do

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500000000,48500000001&\
    message=test_wiadomości_ze_skróconym_linkiem_[%idzdo:www.smsapi.pl%]&\
    format=json"
    
    <?php
    
    $params = array(
        'to'       => '48500500500,48500000001',                                        //grupa odbiorców  
        'from'     => 'Test',                                                           //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'message'  => 'test wiadomości ze skróconym linkiem [%idzdo:www.smsapi.pl%]', //treść wiadomości
        'format'   => 'json'
    );
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss(SendSmssBag::withMessage(['48500000000', '48500000001'], 'Hello world! Go: [%idzdo:www.smsapi.pl%]'));
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000,48500000001,48500000002", message="treść wiadomości link: [%idzdo:www.smsapi.pl%]", from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmssWithShortUrl {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                SMSSend action = smsApi.actionSend(to, "Hello world! Go: [%idzdo:www.smsapi.pl%]");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    W celu wysłania wiadomości zawierającej skrócony link, SMSAPI udostępnia „skracacz” idz.do. Linki wygenerowane przy pomocy skracacza mają format http://idz.do/ABCD. Aby w treści wiadomości umieścić skrócony link należy w parametrze message dodać [%idzdo:adres_url%]. Każdy kolejny numer w wysyłce otrzyma unikalny link na podstawie którego możliwe jest śledzenie kliknięć oraz informacji m.in. o czasie wywołania linku, typie urządzenia, systemie operacyjnym. Możliwe jest dodanie do 100 numerów w odwołaniu, gdy użyty jest skrócony link.

    Linki indywidualne są ważne przez 30 dni, a linki identyczne dla każdego odbiorcy przez 10 lat.

    Wiadomości z linkiem Opt-out

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500000000,48500000001&\
    message=test wiadomości_z_linkiem_Opt-out_[%opt_out_link%]&\
    format=json"
    
    <?php
    $params = array(
        'to'       => '48500500500,48500000001',                                //grupa odbiorców  
        'from'     => 'Test',                                                   //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames 
        'message'  => 'test wiadomości z linkiem Opt-out [%opt_out_link%]',        //treść wiadomości
        'format'   => 'json'
    );
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmssBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Sms[] $smss */
    $smss = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSmss(SendSmssBag::withMessage(['48500000000', '48500000001'], 'test wiadomości z linkiem Opt-out [%opt_out_link%]'));
    
    var_dump($smss);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    send_results = client.sms.send(to="48500000000,48500000001,48500000002", message="test wiadomości z linkiem Opt-out [%opt_out_link%]", from_="Pole nadawcy")
    
    for result in send_results:
        print(result.id, result.points, result.error)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.SmsFactory;
    import pl.smsapi.api.action.sms.SMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendSmssWithOptOut {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SmsFactory smsApi = new SmsFactory(client, proxy);
    
                String[] to = {"000000000", "000000001"};
                SMSSend action = smsApi.actionSend(to, "Hello world! Go: [%opt_out_link%]");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Funkcja Opt-out SMS umożliwia wklejenie w treści wiadomości SMS linka prowadzącego do automatycznego wypisania się z grupy odbiorców na danym koncie w panelu klienta SMS. Aby w treści wiadomości umieścić link OptOut należy w parametrze message dodać [%opt_out_link%]. Wypisane z grupy kontakty znajdą się na liście Wypisani oraz będą wykluczane z przyszłych kampanii.

    Linki Opt-out wygasają po 14 dniach.

    4. Wykorzystanie szablonów

    
    Nazwa Szablonu:         Powiadomienie
    Treść Szablonu:       Witaj [%1%], Twoje zamówienie o numerze [%2%] zostało wysłane. 
    
    curl -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500500500&\
    template=Powiadomienie&\
    param1=Marek&\
    param2=BG12344423&\
    format=json"
    
    <?php
    
    $params = array(
        'to'       => '48500500500',        //numer odbiorczy
        'from'     => 'Test',               //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'template' => 'Powiadomienie',      //nazwa szablonu
        'param1'   => 'Marek',
        'param2'   => 'BG12344423',
        'format'   => 'json'
    );
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Sms\Bag\SendSmsBag;
    use Smsapi\Client\Feature\Sms\Data\Sms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $sendSmsBag = SendSmsBag::withTemplateName('48500000000', 'Powiadomienie');
    $sendSmsBag->setParams([1 => 'Marek', 2 => 'BG12344423']);
    
    /** @var Sms $sms */
    $sms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->smsFeature()
        ->sendSms($sendSmsBag);
    
    var_dump($sms);
    
    
    Treść wysłanej wiadomości:
    Witaj Marek, Twoje zamówienie o numerze BG12344423 zostało wysłane.
    
    

    Przy wykorzystaniu szablonów w bardzo prosty sposób zmienić można treść SMS-ów powiadamiających (w sklepach, serwisach internetowych, klinikach itp.) bez ingerencji w kod skryptu odpowiedzialnego za wysyłanie wiadomości SMS.

    W celu skorzystania z szablonów należy:

    Parametr Opis
    template Nazwa szablonu
    paramN Parametr wstawiany w miejsce [%N%] w szablonie gdzie N to liczba od 1 do 4
    single Jeżeli wiadomość będzie składała się z więcej niż 160 znaków nie zostanie wysłana i zwrócony zostanie ERROR:12 (&single=1)

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    5. mail2SMS

    Aby wysłać SMS-a za pomocą maila należy wysłać maila według schematu:

    ADRES: sms.do@smsapi.pl
    TEMAT: login@haslo_32znaki_w_md5
    TREŚĆ: from=nadawca&to=numer&message=tresc wiadomosci
    ADRES: sms.do@smsapi.pl
    TEMAT: login@8456fkty567gb3bg37b357b3457b3457
    TREŚĆ: from=nadawca&to=numer&message=tresc wiadomosci

    Dodanie parametru raport=1 spowoduje odsyłanie maila z raportem (potwierdzenie wysłania wiadomości lub błąd – jest to przydatne w trakcie testowania usługi):

    ADRES: sms.do@smsapi.pl
    TEMAT: login@8456fkty567gb3bg37b357b3457b3457
    TREŚĆ: from=nadawca&to=numer&raport=1&message=tresc wiadomosci

    Wiadomości mogą być wysyłane w kodowaniu plain / quotedprintable / base64. Oprócz parametrów wymienionych w powyższych przykładach w mail2sms dostępne są wszystkie parametry wymienione w Punkcie 2. Wysyłanie pojedynczych SMS'ów. W celu wysłania wiadomości 2way przez mail2SMS podać jako wartość parametru from ustawić 2way (from=2way). Nazwa nadawcy (zmienna &from=) musi być aktywna.

    6. Sprawdzenie ilości punktów

    
    curl -X GET -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/profile"
    
    
    <?php
    
    function getPoints($token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/profile';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    echo getPoints($token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Profile\Data\Profile;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Profile $profile */
    $profile = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->profileFeature()
        ->findProfile();
    
    var_dump($profile->points);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def get_account_balance():
        r = client.account.balance()
    
        print(r.points, r.pro_count, r.eco_count, r.mms_count, r.vms_gsm_count, r.vms_land_count)
    
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
      "name": "string",
      "email": "string",
      "username": "string",
      "phone_number": "string",
      "payment_type": "prepaid",
      "user_type": "native",
      "points": 0 // Ilość punktów dostępnych na koncie SMSAPI
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Authorization failed",
        "error":"authorization_failed",
        "developer_description":null,
        "errors":null
    }
    
    

    Endpoint profile pozwala na sprawdzenie stanu konta, typu płatności oraz danych przypisanych do konta SMSAPI.


    W przypadku powodzenia odwołania:

    Opowiedź Opis
    points Punkty dostępne na platformie SMSAPI
    name Nazwa firmy
    email Kontaktowy email
    username Nazwa użytkownika SMSAPI
    phone_number Kontaktowy numer telefonu
    payment_type Typ płatności, prepaid lub postpaid
    user_type Typ konta na platformie SMSAPI, native lub subuser


    W przypadku niepowodzenia odwołania:

    Opowiedź Opis
    message Opis błędu
    error Typ błędu
    developer_description Rozszerzona informacja dla developera
    errors Tablica błędów

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    7. Wiadomości MMS

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/mms.do?\
    to=48500000000&\
    subject=Testowy_MMS&\
    smil=[smil]&\
    format=json"
    
    <?php
    
    function mms_send($params, $token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/mms.do';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, $params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = array(
        'to'          => '48500000000',     //numer odbiorcy  
        'subject'     => 'Testowy_MMS',     //pole nadawcy  
        'smil'        => 'smil',            //treść wiadomości w formacie SMIL (przykład poniżej)
        'format'      => 'json'      
    );
    
    echo mms_send($params, $token);
    
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Mms\Bag\SendMmsBag;
    use Smsapi\Client\Feature\Mms\Data\Mms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $smil = '<smil>
        <head>
            <layout>
                <root-layout backgroundColor="#FFFFFF" background-color="#FFFFFF" height="100%" width="100%"/>
                <region id="Image" top="0" left="0" height="50%" width="100%" fit="meet"/>
                <region id="Text" top="50%" left="0" height="50%" width="100%" fit="scroll"/>
            </layout>
        </head>
        <body>
            <par dur="5000ms">
                <img src="http://example.com/image.png" region="Image"/>
            </par>
            <par dur="5000ms">
                <text src="http://example.com/plaintext.txt" region="Text"/>
            </par>
        </body>
    </smil>';
    
    /** @var Mms $mms */
    $mms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->mmsFeature()
        ->sendMms(new SendMmsBag('48500000000', 'Hello world!', $smil));
    
    var_dump($mms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def basic_send_mms():
        client.mms.send(to='48500000000', subject='Temat Wiadomości', \
        smil='<smil>
        <head>
            <layout>
                <root-layout backgroundColor="#FFFFFF" background-color="#FFFFFF" height="100%" width="100%"/>
                <region id="Image" top="0" left="0" height="50%" width="100%" fit="meet"/>
                <region id="Text" top="50%" left="0" height="50%" width="100%" fit="scroll"/>
            </layout>
        </head>
        <body>
            <par dur="5000ms">
                <img src="http://example.com/image.png" region="Image"/>
            </par>
            <par dur="5000ms">
                <text src="http://example.com/plaintext.txt" region="Text"/>
            </par>
        </body>
    </smil>')
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.MmsFactory;
    import pl.smsapi.api.action.mms.MMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendMms {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                MmsFactory mmsApi = new MmsFactory(client, proxy);
    
                MMSSend action = mmsApi.actionSend("000000000", "<smil>...</smil>");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa wiadomość MMS w formacie SMIL:

    
    <smil>
        <head>
            <layout>
                <root-layout backgroundColor="#FFFFFF" background-color="#FFFFFF" height="100%" width="100%"/>
                <region id="Image" top="0" left="0" height="50%" width="100%" fit="meet"/>
                <region id="Text" top="50%" left="0" height="50%" width="100%" fit="scroll"/>
            </layout>
        </head>
        <body>
            <par dur="5000ms">
                <img src="http://hiper.lacze.do/pliku.jpg" region="Image"/>
            </par>
            <par dur="5000ms">
                <text src="http://hiper.lacze.do/pliku.txt" region="Text"/>
            </par>
        </body>
    </smil>
    
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

    
    {
        "count":1,
        "list":[
        {
            "id":"0025459515532275190",
            "points":1,
            "number":"48500000000",
            "date_sent":1535100254,
            "submitted_number":"48500000000",
            "status":"QUEUE",
            "error":null,
            "idx":null
        }
        ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "error":11,
        "message":"Set Content requires parametter smil!"
    }
    
    

    Poniższa tabela przedstawia parametry niezbędne do wysłania wiadomości MMS.

    Parametr Opis
    to Numer odbiorcy wiadomości w formacie 48xxxxxxxxx lub xxxxxxxxx.
    group Nazwa grupy kontaktów z książki telefonicznej, do których ma zostać wysłana wiadomość
    subject Temat wiadomości MMS. Temat może zawierać maksymalnie 30 znaków, w przypadku przekroczenia limitu wiadomość jest odrzucana i zwracany jest błąd 26.
    date Data w formacie unixtime (&date=1287734110) lub ISO 8601 (&date=2012-05-10T08:40:27+00:00) kiedy wiadomość ma być wysłana
    date_validate Ustawienie „1” sprawdza poprawność formatu podanej daty. W przypadku wystąpienia błędnej daty zwrócony zostanie błąd ERROR:54
    smil Wiadomość MMS w formacie SMIL 1.0
    idx Opcjonalny parametr użytkownika wysyłany z wiadomością a następnie zwracany przy wywołaniu zwrotnym CALLBACK. Parametr idx może mieć maksymalnie 255 znaków dopuszczalne są cyfry 0 - 9 oraz litery a – z (wielkość liter nie jest rozróżniana). (&idx=123)
    check_idx Pozwala zabezpieczyć przed wysłanie dwóch wiadomości z identyczną wartością parametru idx. W przypadku ustawienia parametru (&check_idx=1) system sprawdza czy wiadomość z takim idx już została przyjęta, jeśli tak zwracany jest błąd 53.
    notify_url Parametr do podawania URL do skryptu callback do odbierania raportów doręczeń. Jeżeli na koncie nie ma ustawionego stałego adresu callback dlr lub jeżeli dla tej wiadomości adres ten ma być inny niż stały można go podać w parametrze &notify_url.
    test Wiadomość nie jest wysyłana, wyświetlana jest jedynie odpowiedź (w celach testowych). (&test=1)
    format Dla &format=json powoduje, że zwrotka z API wysyłana jest w formacie JSON

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    8. Wiadomości VMS

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/vms.do?\
    to=48500000000&\
    tts=treść_Wiadomości&\
    format=json"
    
    
    <?php
    
    function vms_send($params, $token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/vms.do';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, $params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = array(
        'to'          => '48500000000',                     //numer odbiorcy  
        'file'        => 'http://hiper.lacze.do/pliku.wav', //ścieżka do pliku audio
        //'tts'       => 'Treść_Wiadomości',             //zamiennie z file
        //'tts_lector'=> 'Maja',                            //zamiennie z file: Ewa, Jan, Maja, Jacek
        'format'      => 'json'          
        );
    
    echo vms_send($params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Vms\Bag\SendVmsBag;
    use Smsapi\Client\Feature\Vms\Data\Vms;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Vms $vms */
    $vms = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->vmsFeature()
        ->sendVms(new SendVmsBag('48500000000', 'Hello world!'));
    
    var_dump($vms);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl/", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def basic_send_vms():
        client.vms.send(to='48500000000', tts='treść wiadomości VMS')
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.VmsFactory;
    import pl.smsapi.api.action.vms.VMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendVmsTTS {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                VmsFactory vmsApi = new VmsFactory(client, proxy);
    
                VMSSend action = vmsApi.actionSend("000000000", "Hello world!");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Lub:

    curl -X POST -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/vms.do?\
    to=48500000000&\
    file=http://hiper.lacze.do/pliku.wav&\
    format=json"
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def send_vms_from_file():
        client.vms.send_flash(to='some-number', file='/path/to/vms/file')
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.VmsFactory;
    import pl.smsapi.api.action.vms.VMSSend;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    import java.io.File;
    import java.io.IOException;
    
    public class SendVmsFromFile {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                VmsFactory vmsApi = new VmsFactory(client, proxy);
    
                VMSSend action = vmsApi.actionSend("000000000", new File("/path/to/vms/file"));
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

    
    {
        "count":1,
        "list":[
        {
            "id":"0006759312242528650",
            "points":1,
            "number":"48500000000",
            "date_sent":1535100067,
            "submitted_number":"48500000000",
            "status":"QUEUE",
            "error":null,
            "idx":null
        }
        ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "error":23,
        "message":"Remote get error: http:\/\/hiper.lacze.do\/pliku.wav"
    }
    
    

    Poniższa tabela przedstawia parametry do wysłania wiadomości VMS:

    Parametr Opis
    to Numer odbiorcy wiadomości w formacie 48xxxxxxxxx lub xxxxxxxxx.
    group Nazwa grupy kontaktów z książki telefonicznej, do których ma zostać wysłana wiadomość
    from Własny numer dzwoniący dodany w panelu klienta
    tts Treść wiadomości głosowej w postaci tekstu. Tekst powinien być podawany w kodowaniu UTF-8, w przeciwny razie zostanie zwrócony błąd Error:11.
    tts_lector Określa nazwę lektora czytającego wpisany tekst wiadomości VMS. Dostępne wartości: ewa, jacek, jan, maja. Domyślna wartość to ewa. W przypadku podania błędnej wartości pojawi się błąd ERROR:35
    file Treść wiadomości w postaci pliku wave, akceptowalny link do pliku umieszczonego w sieci lub plik wysłany postem metodą multipart form-data
    date Data w formacie unixtime (&date=1287734110) lub ISO 8601 (&date=2012-05-10T08:40:27+00:00) kiedy wiadomość ma być wysłana
    date_validate Ustawienie „1” sprawdza poprawność formatu podanej daty. W przypadku wystąpienia błędnej daty zwrócony zostanie błąd ERROR:54
    try Ilość prób połączenia (dopuszczalne wartości od 1 do 6)
    interval Czas w sekundach po jakim powtórzone ma być połączenie w przypadku jego nieodebrania lub odrzucenia (dopuszczalne wartości od 300 do 7200s)
    skip_gsm Ustawienie tego parametru (&skip_gsm=1) spowoduje pominięcie telefonów komórkowych podczas wysyłki i wysłanie wiadomości tylko do numerów stacjonarnych
    check_idx Pozwala zabezpieczyć przed wysłanie dwóch wiadomości z identyczną wartością parametru idx. W przypadku ustawienia parametru (&check_idx=1) system sprawdza czy wiadomość z takim idx już została przyjęta, jeśli tak zwracany jest błąd 53.
    notify_url Parametr do podawania URL do skryptu callback do odbierania raportów doręczeń. Jeżeli na koncie nie ma ustawionego stałego adresu callback dlr lub jeżeli dla tej wiadomości adres ten ma być inny niż stały można go podać w parametrze &notify_url.
    test Wiadomość nie jest wysyłana, wyświetlana jest jedynie odpowiedź (w celach testowych). (&test=1)
    format Dla &format=json powoduje, że zwrotka z API wysyłana jest w formacie JSON

    W razie problemów podczas odwoływania się do podstawowego adresu URL można wykorzystać adres URL backup https://api2.smsapi.pl/

    9. Raporty Callback

    Usługa callback pozwala na otrzymywanie aktualizacji statusów wysyłek (raportów doręczeń), odebranych wiadomości SMS/MMS, kliknięć w skrócone linki (idz.do) lub sprawdzeń numerów w bazie HLR do endpointa skonfigurowanego po stronie użytkownika SMSAPI. Adres URL endpointa wprowadzany jest w panelu klienta SMSAPI. Po wystąpieniu nowego zdarzenia, SMSAPI generuje odwołanie POST lub GET z zestawem danych do endpointa użytkownika SMSAPI.

    Odwołania mogą wystąpić z podanych poniżej adresów IP: 3.123.166.170, 89.174.81.98, 91.185.187.219, 213.189.53.211, 31.186.83.18, 212.91.26.253

    Żądania na adres wywołania zwrotnego są ponawiane cyklicznie aż do ich odbioru bądź archiwizacji powiązanej wiadomości. Wysyłanie żądań na adres wywołania zwrotnego może zostać zablokowane w przypadku wykrycia zbyt dużej ilość błędów podczas transmisji po stronie klienta.

    Raporty SMS

    
    <?php
    
        if($_GET['MsgId'] && $_GET['status'] ) {
            mysqli_select_db('database_name',mysqli_connect('localhost','login','password'));
            $arIds = explode(',',$_GET['MsgId']);
            $arStatus = explode(',',$_GET['status']);
            $arIdx = explode(',',$_GET['idx']);
            if($arIds){ 
                foreach($arIds as $k => $v){
                    mysqli_query("UPDATE sms SET sms_status = '".mysqli_real_escape_string($arStatus[$k])."', 
        sms_index = '".mysqli_real_escape_string($arIdx[$k])."' WHERE sms_id ='".mysqli_real_escape_string($v)."' LIMIT 1");
           }
            mysqli_close();
            echo"OK";
        }
    
    ?>
    
    

    Przykład odpowiedzi:

    a) W przypadku pojedynczej wartości:

        https://example.com/?MsgId=613F1B14346335B944450980&donedate=1631525653&from=Test&idx=1&mcc=260&mnc=3&points=0.0&sent_at=1631525653&status=403&status_name=SENT&to=48500500500&username=smsapi.user
    

    b) W przypadku większej ilości wartości:

        https://example.com/?MsgId=613F14C4346335AE0B1DBA31%2C613F14C4346335AE0B1DBA2E%2C613F14C4346335AE0B1DBA30%2C613F14C4346335AE0B1DBA2F%2C613F14C4346335AE0B1DBA2D&donedate=1631525676%2C1631525676%2C1631525676%2C1631525676%2C1631525676&from=Test%2CTest%2CTest%2CTest%2CTest&idx=%2C%2C%2C%2C&mcc=260%2C260%2C260%2C260%2C260&mnc=3%2C3%2C3%2C3%2C3&points=0.16%2C0.16%2C0.16%2C0.16%2C0.16&sent_at=1631525676%2C1631525676%2C1631525676%2C1631525676%2C1631525676&status=403%2C403%2C403%2C403%2C403&status_name=SENT%2CSENT%2CSENT%2CSENT%2CSENT&to=48500500500%2C48500500500%2C48500500500%2C48500500500%2C48500500500&username=smsapi.user%2Csmsapi.user%2Csmsapi.user%2Cmsmsapi.user%2Csmsapi.user
    

    W celu sprawdzenia statusu wiadomości należy w panelu klienta Adresy Callback ustawić adres do skryptu do którego przekazywany będzie raport doręczenia wiadomości. Aby móc wprowadzić adres callback, skrypt musi być umieszczony w podanej lokalizacji.

    Przykład: http://www.moja_strona.pl/status_update.php

    Do skryptu wysyłane są parametry za pomocą metody GET. Każdy parametr może posiadać do 5 wartości w zależności od ilości wiadomości w raporcie. Ilość wartości jest taka sama dla każdego parametru.

    Parametr Opis
    MsgId ID wysłanej wiadomości.Parametr MsgId jest parametrem o zmiennej długości, ale nie większej niż 32 znaki.
    status Kod statusu doręczenia. Lista statusów
    status_name Nazwa statusu doręczenia. Lista statusów
    idx Opcjonalny parametr użytkownika wysłany z SMS'em
    sent_at Czas podany w formacie unixtime reprezentujący datę wysłania wiadomośći
    donedate Czas dostarczenia wiadomości w formacie unixtime
    username Nazwa użytkownika wysyłającego wiadomość
    points Ilość punktów pobranych za wysyłkę wiadomości
    from Pole nadawcy z którym została wysłana wiadomość
    to Numer na jaki wysyłana była wiadomość
    mcc Kod Mobile Country Code identyfikujący jednoznacznie kraj przynależności numeru
    mnc Kod Mobile Network Code identyfikujący jednoznacznie sieć w ramach kraju (MCC) do której numer należy.

    Raporty MMS

    W celu sprawdzenia statusu wiadomości należy w panelu klienta Adresy Callback ustawić adres do skryptu do którego przekazywany będzie raport doręczenia wiadomości.

    Przykład: http://www.moja_strona.pl/status_update.php

    Poniższa tabela przedstawia wysyłane parametry:

    Parametr Opis
    MsgId ID wysłanej wiadomości. Parametr MsgId jest parametrem o zmiennej długości, ale nie większej niż 32 znaki.
    status Kod doręczenia wiadomości
    to Numer na jaki wysyłana była wiadomość
    idx Opcjonalny parametr użytkownika wysłany z MMS'em
    donedate Czas dostarczenia wiadomości w formacie unixtime
    username Nazwa użytkownika z którego została wysłana wiadomość

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    Raport VMS

    W celu sprawdzenia statusu wiadomości należy w panelu klienta Adresy Callback ustawić adres do skryptu do którego przekazywany będzie raport doręczenia wiadomości.

    Przykład: http://www.moja_strona.pl/status_update.php

    Poniższa tabela przedstawia wysyłane parametry:

    Parametr Opis
    MsgId ID wysłanej wiadomości. Parametr MsgId jest parametrem o zmiennej długości, ale nie większej niż 32 znaki.
    status Kod doręczenia wiadomości
    to Numer na jaki wysyłana była wiadomość
    idx Opcjonalny parametr użytkownika wysłany z MMS'em
    donedate Czas dostarczenia wiadomości w formacie unixtime
    username Nazwa użytkownika z którego została wysłana wiadomość
    pressed Klawisz wybrany przez odbiorcę wiadomości podczas jej odsłuchiwania
    hangup_time Czas trwania połączenia

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    Wysyłki masowe

    Do skryptu CALLBACK dla wysyłek masowych wysyłane jest odwołanie w momencie rozpoczęcia wysyłania danej wysyłki. Odwołanie zawiera parametry przedstawione w tabeli poniżej. W celu włączenia CALLBACK'a dla wysyłek masowych należy w panelu klienta Adresy Callback ustawić adres do skryptu do którego przekazywane będą statusy wysyłek masowych.

    Przykład: http://www.moja_strona.pl/bulk_callback.php

    Poniższa tabela przedstawia wysyłane parametry:

    Parametr Opis
    type Typ wiadomości SMS/MMS/VMS
    all Liczba wiadomości (numerów) w wysyłce.
    points Liczba pobranych punktów za wysyłkę.
    to Określa gdzie (za pomocą której zakładki bramki SMS) została wysłana wysyłka csv, csv_and_text lub phonebook.
    info W przypadku wysyłki to numerów z Bazy lista grup do których zostały wysłane wiadomości.
    text Tekst wysłanej wiadomości.

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    Kliknięcia idz.do

    W celu sprawdzenia kliknięć w link idz.do należy w panelu klienta Adresy Callback ustawić adres do skryptu do którego przekazywany będzie raport kliknięć idz.do.

    Przykład: http://www.moja_strona.pl/idzdo_callback.php

    Poniższa tabela przedstawia wysyłane parametry:

    Parametr Opis
    MsgId ID wysłanej wiadomości. Parametr MsgId jest parametrem o zmiennej długości, ale nie większej niż 32 znaki.
    MsgIdx Opcjonalny parametr wysyłany z wiadomością (idx)
    suffix Sufiks skróconego adresu, np. Hq9Y(dla http://idz.do/Hq9Y)
    to Numer na jaki wysyłana była wiadomość
    click_date Czas pierwszego otwarcia odnośnika w formacie unixtime
    device Typ urządzenia
    operating_system System operacyjny
    browser Rodzaj przeglądarki
    username Nazwa użytkownika z którego została wysłana wiadomość
    ip Adres IP z którego nastąpiło kliknięcie w skrócony link

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    10. Odbiory Wiadomości

    Serwis SMSAPI oferuje również odbiór wiadomości SMS oraz MMS. Odbierać można wiadomości SMS i/lub MMS wysłane na wykupiony numer dedykowany lub odpowiedzi na wysłane wiadomości 2way.

    Jeśli odpowiedź na wiadomość 2way zostanie wysłana po upływie 24 godzin, nie gwarantujemy jej przypisania do konta klienta.

    Odbiór SMS

    
    <?php
    
        function messageReceive()
        {
            $received   = $_POST;
            $content = print_r($received, true);
            $sms_from   = $received['sms_from'];
            $sms_to     = $received['sms_to'];
            $sms_date   = $received['sms_date'];
            $sms_text   = $received['sms_text'];
            $username   = $received['username'];
    
            $filename = "sms.log";
    
            file_put_contents($filename, $content);
    
            if (is_file($filename)) {
                return true;
                } else {
                return false;
                }
        }
    
        if ($_POST) {
            if (messageReceive() === true) {
                echo "OK";
            }
        }
    
    ?>
    
    

    Odbiór wiadomości odbywać się będzie za pomocą skryptu, do którego adres należy ustawić w Adresy Callback.

    Działanie skryptu opisane jest poniżej:

    Po odebraniu wiadomości odwoływać będziemy się do skryptu stworzonego przez Państwa, który powinien obsługiwać następujące parametry z tablicy POST:

    Parametr Opis
    sms_to numer telefonu odbiorcy
    sms_from numer telefonu nadawcy
    sms_text treść wiadomości
    sms_date czas w postaci unixtime pobrany z SMS'a
    username nazwa użytkownika (login) do którego wiadomość została przydzielona
    MsgId id wiadomości 2way na którą jest to odpowiedź, dla odpowiedzi na numer dedykowany pole to będzie puste. Parametr MsgId jest parametrem o zmiennej długości, ale nie większej niż 32 znaki.

    Dane wysyłane są w kodowaniu UTF8.

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    Odbiór MMS

    
    <?php
    
        function receiveMms()
        {
            $received = false;
    
            foreach ($_FILES as $plik) 
            {
                if (is_uploaded_file($plik['tmp_name']))
                {
                    if (move_uploaded_file($plik['tmp_name'],'mms/'.$plik['name'])) {
                        $received = true;
                    }
                }
            }
            return $received;
        }
    
    
        if ($_FILES) {
            if (receiveMms() === true) {
                echo "OK";
            }
        }
    
    ?>
    
    

    Odbiór wiadomości odbywać się będzie za pomocą skryptu, do którego adres należy ustawić w Adresy Callback. Działanie skryptu opisane jest poniżej:Po odebraniu wiadomości odwoływać będziemy się do skryptu stworzonego przez Państwa, który powinien obsługiwać parametry z tablicy POST oraz FILES podane poniżej:

    Tablica POST:

    Parametr Opis
    mms_to numer telefonu odbiorcy
    mms_from numer telefonu nadawcy
    mms_subject temat wiadomości
    mms_date czas w postaci unixtime pobrany z MMS'a

    Tablica FILES:

    Parametr Opis
    name oryginalna nazwa wysyłanego pliku
    type typ MIME wysyłanego pliku (JPEG, GIF, ...)
    tmp_name tymczasowa nazwa pliku, który został wysłany na serwer
    error numer błędu (0 oznacza prawidłowe wysłanie)
    size rozmiar wysyłanego pliku (w bajtach)

    Dane wysyłane są w kodowaniu UTF8.

    Skrypt powinien zwracać OK (string, nie sam status HTTP), w innym przypadku nastąpią ponowne odwołania.

    11. HLR

    Przykład odwołania:

    curl -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/hlr.do?\
    number=48500000000&\
    format=json"
    
    <?php
    $params = array(
        'access_token'  => 'token_api_oauth',   //token SMSAPI
        'number'        => '48500000000',       //numer do sprawdzenia
        'format'        => 'json'
    );
    if ($params['access_token']&&$params['number']) {
        $date = '?'.http_build_query($params);
        $file = fopen('https://api.smsapi.pl/hlr.do'.$date,'r');
        $result = fread($file,1024);
        fclose($file);
        echo $result;
    }
    ?>
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Hlr\Bag\SendHlrBag;
    use Smsapi\Client\Feature\Hlr\Data\Hlr;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Hlr $hlr */
    $hlr = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->hlrFeature()
        ->sendHlr(new SendHlrBag('48500000000'));
    
    var_dump($hlr);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def check_number():
        r = client.hlr.check_number(number='48500000000')
    
        print(r.status, r.number, r.id, r.price)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.hlr.HLRCheckNumber;
    import pl.smsapi.api.action.hlr.HlrFactory;
    import pl.smsapi.api.response.CheckNumberResponse;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class SendHlr {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                HlrFactory hlrApi = new HlrFactory(client, proxy);
    
                HLRCheckNumber action = hlrApi.actionCheckNumber("000000000");
    
                CheckNumberResponse phoneNumbers = action.execute();
    
                phoneNumbers.list.forEach(phoneNumber -> System.out.println(phoneNumber.getStatus()));
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź (format JSON):

    a) w przypadku sukcesu:

    {
        "status": "OK", 
        "number": "48100200300",
        "id": "46567088",
        "price": "0.0500"
    }
    

    b) w przypadku niepowodzenia:

    {
        "status":"ERROR",
        "number":"481002003001", // nieprawidłowy numer telefonu
        "error":13               // kod błędu
    }
    

    Przykładowa odpowiedź (tekst):

    a) w przypadku sukcesu:

    OK:<NUMBER>:<ID>:<POINTS>;OK:<NUMBER>:<ID>:<POINTS>;...;...
    OK:44123123123:80625:0.006;OK:44234234234:80627:0.006;
    
    

    b) w przypadku niepowodzenia:

    ERROR:<NUMBER>:<ERR>;ERROR:<NUMBER>:<ERR>;...;...
    OK:44123123123:80625:0.006;ERROR:4433412333:13;
    
    

    gdzie:

    <NUMBER>    Sprawdzany numer telefonu
    <ID>        Unikalne ID
    <POINTS>    Liczba wykorzystanych punktow
    <ERR>       Kod błędu
    

    Przykład danych wysyłanych do skryptu callback (przesłana do podanego adresu URL w postaci tablicy POST):

    Array
    (
        [0] => Array
            (
                [id] =>  80625
                [number] => 48600600600
                [mcc] => 260
                [mnc] => 2
                [info] => T-Mobile
                [status] => OK
                [date] =>  1302703609
                [ported] => 0
                [ported_from] => null
            )
        [1] => Array
            (
                [id] =>   80627
                [number] => 48500600700
                [mcc] => 260
                [mnc] => 2
                [info] => ABSENT_SUBSCRIBER
                [status] => FAIL
                [date] =>  1302703609
                [ported] => 0
                [ported_from] => null
            )
    )
    

    HLR (ang. Home Location Register) – Rejestr Abonentów Macierzystych – element infrastruktury telekomunikacyjnej zawierający informacje o każdym aktywnym numerze GSM. W celu skorzystania z tej opcji należy wysłać żądanie pod adres:

    z parametrami opisanymi w tabeli poniżej. W jednym odwołaniu może znajdować się do 20 numerów. Informacje o numerach będą wysłane do skryptu do którego adres należy podać w panelu klienta na stronie Adresy Callback w polu „Adres callback - odwołania HLR”.

    Ważne aby wprowadzony adres URL prowadził do istniejącego, działającego skryptu. Po sprawdzeniu numeru w systemie HLR informacja o nim zostanie przesłana do podanego adresu URL w postaci tablicy POST.


    Tabelę błędów systemu HLR sprawdzić można w zakładce Kody błędów.



    Poniższa tabela przedstawia parametry odwołania HLR:

    Parametr Opis
    number Numer/y, które mają być sprawdzone w HLR.
    idx Opcjonalny parametr użytkownika wysyłany z odwołaniem, a następnie zwracany przy wywołaniu zwrotnym CALLBACK. Parametr idx może mieć maksymalnie 255 znaków. Dopuszczalne są cyfry 0 - 9 oraz litery a – z (wielkość liter nie jest rozróżniana). (&idx=123)
    format Dla &format=json powoduje, że zwrotka z API wysyłana jest w formacie JSON.


    Poniższa tabela przedstawia parametry wysyłane do skryptu:

    Parametr Opis
    id id zwrócony podczas sprawdzania numeru
    number sprawdzany numer
    mcc numer identyfikujący kraj (ang. Mobile Country Code)
    mnc numer sieci w danym kraju (ang. Mobile Network Code)
    info nazwa sieci, do której należy numer, lub opis błędu
    status OK kiedy numer jest poprawny, FAIL kiedy numer jest błędny (np. wyłączony, nieaktywny itp.)
    date Data w formacie UNIX timestamp, kiedy numer był sprawdzany
    ported 0 jeżeli numer jest nieprzeniesiony, 1 jeżeli numer jest przeniesiony
    ported_from null kiedy numer jest nieprzeniesiony lub nazwa sieci z której numer został przeniesiony
    idx Opcjonalny parametr użytkownika wysłany z zapytaniem HLR

    Skrypt powinien zwracać OK, w innym przypadku nastąpią ponowne odwołania.

    12. Baza Kontaktów

    Endpoint contacts pozwala na przeprowadzanie operacji na kontaktach.

    Wyświetlanie kontaktów

    
    curl -X GET -H "Authorization: Bearer token_api_oauth" https://api.smsapi.pl/contacts?\
    birthday_date=between%281997-02-24%2C%202002-02-24%29
    
    
    
    <?php
    
    function getContact($params, $token)
    {
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/contacts?'.$params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth";     //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = 'phone_number=48500500500'; //parametr = wyszukiwane
    //lub w przypadku operatorów:
    // $params = 'Pole_dodatkowe=9   -- Zwróci kontakty dla których pole dodatkowe jest równe 9, 90, 99 itd.
    // $params = 'Pole_dodatkowe=between(9,11) -- Zwróci kontakty dla których pole dodatkowe jest równe np. 10.
    
    echo getContact($params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Contacts\Bag\FindContactsBag;
    use Smsapi\Client\Feature\Contacts\Data\Contact;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $findContactsBag = new FindContactsBag();
    $findContactsBag->phoneNumber = 48500000000;
    
    /** @var Contact[] $contacts */
    $contacts = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->contactsFeature()
        ->findContacts($findContactsBag);
    
    var_dump($contacts);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def get_all_contacts():
        l = client.contacts.list_contacts()
    
        for c in l:
            print(c.id, c.first_name, c.last_name, c.phone_number)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.contacts.Contacts;
    import pl.smsapi.api.action.contacts.ContactsFactory;
    import pl.smsapi.api.action.contacts.ContactsList;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class ListContacts {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                ContactsFactory contactsApi = new ContactsFactory(client, proxy);
    
                ContactsList action = contactsApi.actionList();
                action.filterByPhoneNumber("48500000000");
    
                Contacts contacts = action.execute();
    
                contacts.list.forEach(contact -> System.out.println(contact.email));
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
       "size":1,
       "collection":[
          {
             "id":"5b83ba81a788494a0469490f",
             "first_name":"Imię",
             "last_name":"Nazwisko",
             "birthday_date": "1998-03-09",
             "phone_number":"48500000000",
             "email":"bok@smsapi.pl",
             "gender":"male",
             "city":"Miasto",
             "country":"Poland",
             "source":"source",
             "date_created":"2018-08-27T10:46:57+02:00",
             "date_updated":"2018-08-27T10:46:57+02:00",
             "groups":[
                {
                   "id":"59a3ca1fa78849062837cd0c",
                   "name":"default",
                   "date_created":"2017-08-28T09:45:35+02:00",
                   "date_updated":"2017-08-28T09:45:35+02:00",
                   "description":"",
                   "created_by":"login",
                   "idx":null,
                   "contact_expire_after":null,
                   "contacts_count":null
                }
             ]
          }
       ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Authorization failed",
        "error":"authorization_failed",
        "errors":null
    }
    
    

    Poniższe parametry pozwalają w tej funkcji na filtrowanie listy kontaktów. Szukanie odbywa się case-insensitive.

    Istnieje także możliwość filtrowania po polach własnych. Można je dodać w Panelu Klienta Pola własne.

    Parametr Opis
    q Parametr pozwala wyszukać kontakty zawierające podany ciąg znaków w ramach podstawowych pól w bazie kontaktów tj. imię, nazwisko, numer telefonu, email, miejscowość.
    offset Listowanie kontaktu od podanej pozycji.
    limit Limit klientów którzy mają zostać wylistowani.
    sort Parametr określa pole w bazie kontaktów po którym zostanie wykonane sortowanie danych. Kierunek rosnący to np. sort=last_name natomiast kierunek malejący to np. sort=-last_name.
    phone_number Listowanie kontaktu o podanym numerze telefonu.
    email Listowanie kontaktu o podanym adresie email.
    first_name Listowanie kontaktów o podanym imieniu.
    last_name Listowanie kontaktów o podanym nazwisku.
    group_id Listowanie kontaktów należących do określnej grupy (należy podać groupID).
    gender Listowanie kontaktów o podanej płci, male lub female.
    birthday_date Listowanie kontaktów o podanej dacie urodzin. Data podawana jest w formacie RRRR-MM-DD.

    Do wyszukiwania można także użyć poniższych operatorów. Mogą one nie działać ze wszystkimi typami parametrów.

    Operator Opis
    gt Operator "większe niż" zwraca kontakty gdzie dana wartość jest większa niż podana w parametrze.
    lt Operator "mniejsze niż" zwraca kontakty gdzie dana wartość jest mniejsza niż podana w parametrze.
    gte Operator "większe lub równe" zwraca kontakty gdzie dana wartość jest większa lub równa podanej w parametrze.
    lte Operator "mniejsze lub równe" zwraca kontakty gdzie dana wartość jest mniejsza lub równa podanej w parametrze.
    eq Operator "równy" zwraca kontakty gdzie dana wartość jest równa tej podanej w parametrze.
    = Operator "like" zwraca kontakty w których dana część wartości zgadza się z podanym parametrem.
    between Zwraca kontakty których wartość znajduje się pomiędzy dwoma wartościami podanymi w parametrze.

    Dodawanie kontaktów

    
    curl -X POST "https://api.smsapi.pl/contacts" -H "Authorization: Bearer token_api_oauth" -d\
    "phone_number=48500000000&email=bok@smsapi.pl&first_name=imie&last_name=nazwisko&gender=płeć\
    &description=opis&city=miasto&groups=default"
    
    
    
    <?php
    
    function contactsCreate($params, $token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/contacts';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, $params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = http_build_query(array(
        'phone_number'  => '500000000',      //numer telefonu
        'email'         => 'bok@smsapi.pl',  //adres email
        'first_name'    => "Imię", 
        'last_name'     => "Nazwisko",
        'gender'        => "Płeć",             // male (mężczyzna) lub female (kobieta)
        'birthday_date' => "Data urodzenia", // RRRR-MM-DD
        'city'          => "Miasto",
        'source'        => "source",
    ));
    
    echo contactsCreate($params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Contacts\Bag\CreateContactBag;
    use Smsapi\Client\Feature\Contacts\Data\Contact;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Contact $contact */
    $contact = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->contactsFeature()
        ->createContact(CreateContactBag::withEmail('example@example.com'));
    
    var_dump($contact);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def create_contact():
        c = client.contacts.create_contact(
            first_name='imie',
            last_name='nazwisko',
            phone_number=48500000000,
            email='adres email',
            birthday_date='1970-01-01',
            gender='{male|female|undefined}',
            city='Miasto',
            description='opis')
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.contacts.ContactAdd;
    import pl.smsapi.api.action.contacts.ContactsFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class AddContact {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                ContactsFactory contactsApi = new ContactsFactory(client, proxy);
    
                ContactAdd action = contactsApi.actionAdd();
                action.withEmail("example@example.com");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
        "id":"5b802315a788494a04690d1d",
        "first_name":"string",
        "last_name":"string",
        "phone_number":"48500000000",
        "email":"bok@smsapi.pl",
        "gender":"płeć",
        "city":"miasto",
        "date_created":"2018-08-24T17:24:05+02:00",
        "date_updated":"2018-08-24T17:24:05+02:00",
        "description":"opis",
        "groups":
        [
            {
                "id":"59a3ca1fa78849062837cd0c",
                "name":"default",
                "date_created":"2017-08-28T09:45:35+02:00",
                "date_updated":"2017-08-28T09:45:35+02:00",
                "description":"",
                "created_by":"username",
                "idx":null,
                "contact_expire_after":null,
                "contacts_count":null
                }
        ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Contact already exists",
        "error":"contact_conflict",
        "code":409,
        "errors":[],
        "developer_description":null
    }
    
    
    Parametr Opis
    phone_number Numer telefonu kontaktu.
    email Adres email kontaktu.
    first_name Imię kontaktu.
    last_name Nazwisko kontaktu.
    gender Płeć kontaktu, male lub female.
    birthday_date Data urodzenia kontaktu podana w formacie RRRR-MM-DD
    city Miejscowość przypisana do kontaktu.
    description Opis kontaktu w bazie klienta. Może zawierać dowolny ciąg znaków.


    W przypadku powodzenia odwołania:

    Opowiedź Opis
    id ID kontaktu
    first_name Imię kontaktu zapisane w bazie kontaktów.
    last_name Nazwisko kontaktu zapisane w bazie kontaktów.
    phone_number Numer telefonu kontaktu zapisany w bazie kontaktów.
    email Adres email kontaktu zapisany w bazie kontaktów.
    gender Płeć kontaktu zapisana w bazie kontaktów
    city Miejscowość przypisana do kontaktu, zapisana w bazie kontaktów
    date_created Data stworzenia kontaktu w bazie
    date_updated Data ostatniej aktualizacji kontaktu w bazie
    description Opis kontaktu w bazie kontaktów
    groups Grupy do jakich należy kontakt


    W przypadku niepowodzenia odwołania:

    Opowiedź Opis
    message Opis błędu.
    error Typ błędu.
    errors Tablica błędów.

    Edycja kontaktów

    Funkcja pozwala na edycję kontaktu na podstawie jego ID.

    
    curl -X PUT -H "Content-Type: application/json" -H "Authorization: Bearer token_api_oauth" -d 'email=tech@smsapi.pl\
    &phone_number=500000003&email=tech@smsapi.pl&first_name=Imię&last_name=Nazwisko&gender=Płeć' https://api.smsapi.pl/contacts/Id_kontaktu
    
    
    
    <?php
    
    function putContact($id,$params,$token)
    {
    
        static $content;
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/contacts/'.$id);
        curl_setopt($c, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "PUT");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    
    $params = (array(
        'phone_number'  => '4850000003',   
        'email'         => 'tech@smsapi.pl', 
        'first_name'    => "Imię", 
        'last_name'     => "Nazwisko",
        'gender'        => "Płeć",              // male,female lub mężczyzna,kobieta
        'birthday_date' => "Data Urodzenia",    // RRRR-MM-DD
        'city'          => "Miasto"
    ));
    
    $token = "token_api_oauth";       //https://ssl.smsapi.pl/react/oauth/manage
    $id = "id_kontaktu";              //ID Kontaktu
    
    echo putContact($id, $params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Contacts\Bag\UpdateContactBag;
    use Smsapi\Client\Feature\Contacts\Data\Contact;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $update = new UpdateContactBag('contact_id');
    
    /** @var Contact $contact */
    $contact = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->contactsFeature()
        ->updateContact($update->setName('Imię', 'Nazwisko'));
    
    var_dump($contact);
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def update_contacts():
        c = client.contacts.update_contact(contact_id=1, description='nowy opis', email='nowy adres email')
    
        print(c.id, c.first_name, c.last_name, c.phone_number)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.contacts.ContactEdit;
    import pl.smsapi.api.action.contacts.ContactsFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class EditContact {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                ContactsFactory contactsApi = new ContactsFactory(client, proxy);
    
                ContactEdit action = contactsApi.actionEdit("contact_id");
                action.withFirstName("Name");
                action.withLastName("Lastname");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
       "id":"5b83ba81a788494a0469490f",
       "first_name":"Imię",
       "last_name":"Nazwisko",
       "phone_number":"48500000001",
       "email":"tech@smsapi.pl",
       "gender":"undefined",
       "city":"Miasto",
       "country":"Poland",
       "source":"source",
       "date_created":"2018-08-27T10:46:57+02:00",
       "date_updated":"2018-08-27T14:17:20+02:00",
       "groups":[
          {
             "id":"59a3ca1fa78849062837cd0c",
             "name":"default",
             "date_created":"2017-08-28T09:45:35+02:00",
             "date_updated":"2017-08-28T09:45:35+02:00",
             "description":"",
             "created_by":"username",
             "idx":null,
             "contact_expire_after":null,
             "contacts_count":null
          }
       ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Authorization failed",
        "error":"authorization_failed",
        "errors":null
    }
    
    
    Parametr Opis
    id ID kontaktu
    first_name Imię
    last_name Nazwisko
    phone_number Numer telefonu
    email Kontaktowy email
    gender Płeć
    city Miasto
    date_created Data stworzenia
    date_updated Data ostatniej aktualizacji
    description Opis


    W przypadku powodzenia odwołania:

    Opowiedź Opis
    id ID kontaktu
    first_name Imię
    last_name Nazwisko
    phone_number Numer telefonu
    email Kontaktowy email
    gender Płeć
    city Miasto
    date_created Data stworzenia
    date_updated Data ostatniej aktualizacji
    description Opis
    groups Grupy do jakich należy kontakt


    W przypadku niepowodzenia odwołania:

    Opowiedź Opis
    message Opis błędu
    error Typ błędu
    errors Tablica błędów

    Przypisywanie kontaktu do grupy

    
    curl -X PUT -H "Authorization: Bearer token_api_oauth" 
    'https://api.smsapi.pl/contacts/{contactId}/groups/{groupId}'
    
    
    
    <?php
    
    function putContact($contactId, $groupId, $token)
    {
    
        static $content;
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/contacts/'.$contactId.'/groups/'.$groupId);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "PUT");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    $contactId = "id_kontaktu";
    $groupId = "id_grupy";
    
    echo putContact($contactId, $groupId, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Contacts\Groups\Bag\AssignContactToGroupBag;
    use Smsapi\Client\Feature\Contacts\Data\Contact;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Contact $contact */
    $contact = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->contactsFeature()
        ->groupsFeature()
        ->assignContactToGroup(new AssignContactToGroupBag('contact_id', 'group_id'));
    
    var_dump($contact);
    
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
       "size":1,
       "collection":[
          {
             "id":"1238f47da26ee45dc41fb987",
             "name":"Grupa testowa",
             "date_created":"2022-04-01T12:00:00+02:00",
             "date_updated":"2022-04-01T12:00:00+02:00",
             "description":"",
             "created_by":"smsapi_user",
             "idx":"",
             "contact_expire_after":null,
             "contacts_count":1,
             "permissions":[
                {
                   "username":"smsapi_user",
                   "group_id":"1238f47da26ee45dc41fb987",
                   "write":true,
                   "read":true,
                   "send":true
                }
             ]
          }
       ]
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Authorization failed",
        "error":"authorization_failed",
        "errors":null
    }
    
    

    Funkcja pozwala na przypisanie kontaktu do wybranej grupy na podstawie jego ID.

    Parametr Opis
    contactId ID kontaktu
    groupId ID grupy




    Aby usunąć kontakt z wybranej grupy, należy wysłać odwołanie typu DELETE zamiast PUT z takimi samymi parametrami.

    Usuwanie kontaktów

    Funkcja pozwala na usunięcie kontaktu na podstawie jego ID.

    
    curl -X "DELETE" -H "Authorization: Bearer token_api_oauth" \
    https://api.smsapi.pl/contacts/Id_kontaktu
    
    
    
    <?php
    
    function deleteContact($contactID,$token)
    {
        $url = "https://api.smsapi.pl/contacts/".$contactID;
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "DELETE");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $contactID = "id_kontaktu";   //Id kontaktu który ma zostać usunięty
    $token = "token_api_oauth";   //https://ssl.smsapi.pl/react/oauth/manage
    
    echo deleteContact($contactID,$token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Contacts\Bag\DeleteContactBag;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->contactsFeature()
        ->deleteContact(new DeleteContactBag('000000000000000000000000'));
    
    
    
    from smsapi.client import Client
    
    client = Client("https://api.smsapi.pl", access_token="%SMSAPI_ACCESS_TOKEN%")
    
    def remove_contact():
        client.contacts.delete_contact(contact_id=1)
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.contacts.ContactDelete;
    import pl.smsapi.api.action.contacts.ContactsFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class DeleteContact {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                ContactsFactory contactsApi = new ContactsFactory(client, proxy);
    
                ContactDelete action = contactsApi.actionDelete("contact_id");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    13. Czarna Lista

    Czarna lista pozwala na dodanie numerów telefonów do których blokowane będą wysyłki wiadomości SMS, MMS oraz VMS z danego konta. Data ważności określa do kiedy mają być blokowane wysyłki na dany numer.

    Wyświetlanie Czarnej listy

    Funkcja pozwala na wyświetlenie czarnej listy.

    
    curl -H "Authorization: Bearer token_api_oauth" -H \  
    "Content-Type: application/json" -X GET https://api.smsapi.pl/blacklist/phone_numbers
    
    
    
    <?php
    
    function getBlacklist($token)
    {
    
        static $content;
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/blacklist/phone_numbers');
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    echo getBlacklist($token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Blacklist\Bag\FindBlacklistedPhoneNumbersBag;
    use Smsapi\Client\Feature\Blacklist\Data\BlacklistedPhoneNumberFactory;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Blacklist $blacklist */
    $blacklist = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->blacklistFeature()
        ->findBlacklistedPhoneNumbers(new FindBlacklistedPhoneNumbersBag());
    
    var_dump($blacklist);
    
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    [{
        "id":"ID_wpisu", 
        "phone_number":"48500000000", 
        "created_at":"2018-11-08T09:36:53+01:00",
        "expire_at":"2021-03-16"
    },
    {
        "id":"ID_wpisu", 
        "phone_number":"48500000001", 
        "created_at":"2018-11-08T09:36:53+01:00",
        "expire_at":null
    }]
    
    

    b) w przypadku niepowodzenia:

    
    {
        "error": 101,
        "message": "authorization_failed"
    }
    
    
    Parametr Opis
    id Id wpisu
    phone_number Numer telefonu znajdującego się na czarnej liście
    created_at Data dodania numeru na czarną liste
    expire_at Data ważności wpisu na czarnej liście (jeżeli ma wartość "null" nigdy nie wygasa)

    Dodawanie numeru do Czarnej listy

    Funkcja pozwala na dodanie numeru do czarnej listy.

    
    curl -i -H "Authorization: Bearer token_api_oauth" -H  "Content-Type: application/json" -X POST -d \
    '{"phone_number":"48500000000","expire_at":"2021-03-16"}' https://api.smsapi.pl/blacklist/phone_numbers
    
    
    
    <?php
    
    function addNumbertoblacklist($params, $token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/blacklist/phone_numbers';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = array(
            'phone_number'  => '48500000000',
            'expire_at'     => '2021-03-16'     
            );
    
    
    echo addNumbertoblacklist($params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Blacklist\Bag\CreateBlacklistedPhoneNumberBag;
    use Smsapi\Client\Feature\Blacklist\Data\BlacklistedPhoneNumberFactory;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Blacklist $blacklist */
    $blacklist = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->blacklistFeature()
        ->createBlacklistedPhoneNumber(new CreateBlacklistedPhoneNumberBag('48500000000'));
    
    var_dump($blacklist);
    
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    {
        "id":"ID_wpisu", 
        "phone_number":"48500000000", 
        "created_at":"2018-11-08T09:36:53+01:00",
        "expire_at":"2021-03-16"
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "error": 101,
        "message": "authorization_failed"
    }
    
    
    Parametr Opis
    id Id wpisu
    phone_number Numer telefonu znajdującego się na czarnej liście
    created_at Data dodania numeru na czarną liste
    expire_at Data ważności wpisu na czarnej liście (jeżeli ma wartość "null" nigdy nie wygasa)

    Usuwanie numeru z czarnej listy

    Funkcja pozwala na usunięcie numeru z czarnej listy.

    
    curl -X "DELETE" -H "Authorization: Bearer token_api_oauth" \
    https://api.smsapi.pl/blacklist/phone_numbers/Id_wpisu
    
    
    
    <?php
    
    function deleteNumberfromblacklist($token,$Id)
    {
        $url = "https://api.smsapi.pl/blacklist/phone_numbers/".$Id;
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "DELETE");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    };
    
    $Id = '5BE3F5A53738306F740DB6DB';   //Id wpisu który ma zostać usunięty
    $token = "token_api_oauth";         //https://ssl.smsapi.pl/react/oauth/manage
    
    echo deleteNumberfromblacklist($token,$Id);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Blacklist\Bag\DeleteBlacklistedPhoneNumberBag;
    use Smsapi\Client\Feature\Blacklist\Data\BlacklistedPhoneNumberFactory;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Blacklist $blacklist */
    $blacklist = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->blacklistFeature()
        ->deleteBlacklistedPhoneNumber(new DeleteBlacklistedPhoneNumberBag('record_id'));
    
    

    Wyczyszczenie czarnej listy

    Funkcja pozwala na usunięcie wszystkich numerów z czarnej listy.

    
    curl -X "DELETE" -H "Authorization: Bearer token_api_oauth" \
    https://api.smsapi.pl/blacklist/phone_numbers
    
    
    
    <?php
    
    function deleteAllNumbersFromBlacklist($token)
    {
        $url = "https://api.smsapi.pl/blacklist/phone_numbers";
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "DELETE");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    };
    
    $token = "token_api_oauth";         //https://ssl.smsapi.pl/react/oauth/manage
    
    echo deleteAllNumbersFromBlacklist($token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Blacklist $blacklist */
    $blacklist = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->blacklistFeature()
        ->deleteBlacklistedPhoneNumbers();
    
    

    14. Konto użytkownika

    Listowanie użytkowników

    Funkcja pozwala na wyświetlenie listy użytkowników.

    
    curl -i -H "Authorization: Bearer token_api_oauth"\
    -H  "Content-Type: application/json" -X GET https://api.smsapi.pl/subusers
    
    
    
    <?php
    
    function getSubusers($token)
    {
    
        static $content;
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/subusers');
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    echo getSubusers($token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Subusers\Data\Subuser;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Subuser[] $subusers */
    $subusers = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->subusersFeature()
        ->findSubusers();
    
    var_dump($subusers);
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.subusers.Subusers;
    import pl.smsapi.api.action.subusers.SubusersFactory;
    import pl.smsapi.api.action.subusers.SubusersList;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class ListSubusers {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SubusersFactory subusersApi = new SubusersFactory(client, proxy);
    
                SubusersList action = subusersApi.actionList();
    
                Subusers subusers = action.execute();
    
                subusers.list.forEach(subuser -> System.out.println(subuser.username));
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    [{
      "id":"5A5359173738303F2F95B7E2",
      "username":"subuser1",
      "active":true, 
      "description":null,
      "points":{
        "from_account":10.0,
        "per_month":0.0
      }
    },
    {
      "id":"5A5359173738303F2F95B7E2",
      "username":"subuser2",
      "active":true, 
      "description":null,
      "points":{
        "from_account":10.0,
        "per_month":0.0
      }
    }]
    
    

    b) w przypadku niepowodzenia:

    
    {
      "error": 123,
      "message": "error message"
    }
    
    
    Parametr Opis
    id Id użytkownika
    username Nazwa użytkownika
    active "true" - aktywny, "false" - nieaktywny
    description Opis
    from_account Punkty udostępnione przez głównego użytkownika
    per_month Miesięczy odnawialny limit punktów

    Dodawanie użytkownika

    Funkcja pozwala na dodanie użytkownika.

    Przykład:

    
    curl -i -H "Authorization: Bearer token_api_oauth"\ 
    -H  "Content-Type: application/json" -X POST -d \ 
    '{"credentials":{"username":"Nazwa_uzytkownika","password":"Hasło_do_Panelu","api_password":"Hasło_do_API"},\
    "active":"1","description":"Opis","points":{"from_account":"2","per_month":"2"}}'\
    https://api.smsapi.pl/subusers
    
    
    
    <?php
    
    function subuserCreate($params, $token)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/subusers';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    $params = array(
        'credentials'    => array(
            'username'      => 'nazwa_Subużytkownika',     
            'password'      => 'hasło do Panelu Klienta', 
            'api_password'  => 'hasło do API' 
        ),
        'active'         => true,
        'description'    => "opis",     
        'points'         => array( 
            'from_account'  => 2,    //Ilość punktów udostępnionych dla Subkonta
            'per_month'     => 2     //Limit odnawialny dla Subkonta
        )
    
    );
    
    echo subuserCreate($params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Subusers\Bag\CreateSubuserBag;
    use Smsapi\Client\Feature\Subusers\Data\Subuser;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Subuser $subuser */
    $subuser = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->subusersFeature()
        ->createSubuser(new CreateSubuserBag('username', 'password'));
    
    var_dump($subuser);
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.subusers.SubuserAdd;
    import pl.smsapi.api.action.subusers.SubusersFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class AddSubuser {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SubusersFactory subusersApi = new SubusersFactory(client, proxy);
    
                SubuserAdd action = subusersApi.actionAdd("username", "password");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
      "id":"ABCD1234EFGH9876ABCD1234",
      "username":"subuser123",
      "active":true,
      "description":"new subuser for tests",
      "points":
      {
        "from_account":2.0,     //Punkty udostępnione przez głównego użytkownika
        "per_month":2.0         //Miesięczny odnawialny limit punktów
      }
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
      "message":"Username already exists",
      "error":"invalid_domain_logic",
      "errors":[
      {
        "error":"invalid_domain_logic",
        "message":"Username already exists"
      }]
    }
    
    
    Parametr Opis
    username Nazwa dodawanego użytkownika
    password Hasło do panelu klienta SMSAPI dodawanego subkonta
    api_password Hasło do interfejsu API dla użytkownika
    from_account Limit punktów przydzielony użytkownikowi
    per_month Ilość punktów która będzie przypisana do konta użytkownika każdego pierwszego dnia
    active Aktywowanie konta użytkownika (dostępne wartości: 1/true – aktywne, 0/false – nieaktywne, domyślnie wartość równa 0)
    description Dodatkowy opis użytkownika

    Usuwanie użytkownika

    Funkcja pozwala na usunięcie użytkownika na podstawie jego ID.

    
    curl -X "DELETE" -H "Authorization: Bearer token_api_oauth" \
    https://api.smsapi.pl/subusers/{subuser_id}
    
    
    
    <?php
    
    function deleteSubuser($token,$userID)
    {
        $url = "https://api.smsapi.pl/subusers/".$userID;
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "DELETE");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $userID = "subuser_id";     //Id użytkownika który ma zostać usunięty
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    echo deleteSubuser($token,$userID);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Subusers\Bag\DeleteSubuserBag;
    use Smsapi\Client\Feature\Subusers\Data\SubuserFactory;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Subusers $subusers */
    $subusers = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->subusersFeature()
        ->deleteSubuser(new DeleteSubuserBag('subuser_id'));
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.subusers.SubuserDelete;
    import pl.smsapi.api.action.subusers.SubusersFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class DeleteSubuser {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SubusersFactory subusersApi = new SubusersFactory(client, proxy);
    
                SubuserDelete action = subusersApi.actionDelete("subuser_id");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    
    Parametr Opis
    subuser_id Id użytkownika (subkonta)

    Edycja użytkownika

    curl -X PUT -H "Content-Type: application/json" \
    -H "Authorization: Bearer token_api_oauth" -d\
    '{"credentials":{"password":"Hasło_do_Panelu","api_password":"Hasło_do_API"}, \
    "active":"1","description":"Opis","points":{"from_account":"2","per_month":"2"}}'
    'https://api.smsapi.pl/subusers/{subuser_id}'
    
    
    
    <?php
    
    function putSubuser($id,$params,$token)
    {
    
        static $content;
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/subusers/'.$id);
        curl_setopt($c, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "PUT");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $params = array(
        'credentials'    => array(  
            'password'      => 'hasło do Panelu Klienta', 
            'api_password'  => 'hasło do API' 
        ),
        'active'         => true,
        'description'    => "opis",     
        'points'         => array( 
            'from_account'  => 2,    //Ilość punktów udostępnionych dla Subkonta
            'per_month'     => 2     //Limit odnawialny dla Subkonta
        )
    
    );
    
    $token = "token_api_oauth";    //https://ssl.smsapi.pl/react/oauth/manage
    $id = "subuser_id";            //ID Subkonta
    
    echo putSubuser($id, $params, $token);
    
    ?>
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Subusers\Bag\UpdateSubuserBag;
    use Smsapi\Client\Feature\Subusers\Data\Subuser;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Subuser $subuser */
    $updateSubuserBag = new UpdateSubuserBag('000000000000000000000000');
    $updateSubuserBag->active = true;
    
    $subuser = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->subusersFeature()
        ->updateSubuser($updateSubuserBag);
    
    var_dump($subuser);
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.subusers.SubuserEdit;
    import pl.smsapi.api.action.subusers.SubusersFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class EditSubuser {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SubusersFactory subusersApi = new SubusersFactory(client, proxy);
    
                SubuserEdit action = subusersApi.actionEdit("subuser_id");
                action.asActive();
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
      "id":"5A8D6E6F373830607C87B277",
      "username":"Subuser name",
      "active":true,
      "description":"Opis",
      "points":{
        "from_account":2,
        "per_month":2
      }
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
      "error": 123,
      "message": "error message"
    }
    
    

    Zarządzanie kontem odbywa się przez wysłanie metodą GET lub POST danych do adresu połączenia.

    Parametr Opis
    subuser_id Id użytkownika (subkonta)
    token_api_oauth Token przypisany do konta w serwisie SMSAPI
    username Nazwa edytowanego użytkownika bez prefiksu użytkownika głównego
    password Hasło do panelu klienta SMSAPI dodawanego użytkownika
    api_password Hasło do interfejsu API dla użytkownika.
    from_account Limit punktów przydzielony użytkownikowi
    per_month Ilość punktów która będzie przypisana do konta użytkownika każdego pierwszego dnia
    active Aktywowanie konta użytkownika (dostępne wartości: 1 – aktywne, 0 – nieaktywne, domyślnie wartość równa 0)
    description Dodatkowy opis użytkownika

    Udostępnianie pól nadawcy

    
    curl -X PUT -H "Content-Type: application/json" \
    -H "Authorization: Bearer token_api_oauth" \
    -d '{"access":"selected","senders":["pole_nadawcy1","pole_nadawcy3"]}' \
    'https://api.smsapi.pl/subusers/{subuser_id}/shares/sendernames'
    
    
    
    <?php
    
    function putAccess($id,$params,$token)
    {
    
        $c = curl_init();
    
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/subusers/'.$id.'/shares/sendernames');
        curl_setopt($c, CURLOPT_POSTFIELDS, http_build_query($params));
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_CUSTOMREQUEST, "PUT");
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    $id = "subuser_id"; //Id użytkownika (subkonta) któremu modyfikujemy dostęp do pól nadawcy
    
    
    $params = array(
        'access'    => "selected", //none | selected | all 
        'senders'   =>  ["pole_nadawcy1","pole_nadawcy3"]
        );
    
    echo putAccess($id,$params,$token);
    
    ?>
    
    

    Funkcja pozwala na zarządzanie udostępnianymi polami nadawcy użytkowników (subkont).

    Parametr Opis
    subuser_id Id użytkownika (subkonta)
    access Typ dostępu do pól nadawcy konta głównego ("none" - żadne, "selected" - wybrane, "all" - wszystkie)
    senders Tablica z listą pól nadawcy, które mają być udostępnione dla subkonta. Parametr ustawiany w przypadku gdy parametr access = 'selected'

    15. Pola nadawcy

    Sekcja poświęcona zarządzaniu polami nadawcy konta. Zarządzanie udostępnianymi polami nadawcy z konta głównego dla użytkowników (subkont) została opisana w zakładce Konto użytkownika -> Udostępnianie pól nadawcy.

    Dodawanie pola nadawcy

    
    curl -X POST "https://api.smsapi.pl/sms/sendernames" \
    -H "Authorization: Bearer token_api_oauth" -d "sender=nowe_pole_nadawcy"
    
    
    
    <?php
    
    function add_sendername($token, $params)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/sms/sendernames';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_POSTFIELDS, $params);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
        $http_status = curl_getinfo($c, CURLINFO_HTTP_CODE);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth";     //https://ssl.smsapi.pl/react/oauth/manage
    
    
    $params = array(
      'sender' => 'nowe_pole_nadawcy',
    );
    
    echo add_sendername($token, $params);
    
    ?>
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.sms.sendernames.SendernameAdd;
    import pl.smsapi.api.action.sms.sendernames.SendernamesFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class AddSendername {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SendernamesFactory sendernamesApi = new SendernamesFactory(client, proxy);
    
                SendernameAdd action = sendernamesApi.actionAdd("new_sender_name");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
      "sender":"nowe_pole_nadawcy",
      "is_default":false,
      "status":"INACTIVE",
      "created_at":"2020-01-01T00:00:00+02:00"
    }
    
    Zwracany jest również kod HTTP201
    
    

    b) w przypadku niepowodzenia:

    
    {
      "message":"Sendername is not valid",
      "error":"invalid_sender",
      "errors":[
        {
          "error":"invalid_sender",
          "message":"Sendername is not valid"
        }]
    }
    
    

    Funkcja dodawania pól nadawcy wymaga dodatkowej aktywacji. Aby aktywować funkcję prosimy o kontakt z Biurem Obsługi Klienta.

    Dodanie nowego pola nadawcy odbywa się przez wysłanie zapytania metodą POST.

    Parametr Opis
    sender Nazwa pola nadawcy, która ma zostać dodana

    Status pola nadawcy

    Funkcja pozwala na wyświetlenie statusu pola nadawcy.

    curl -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms/sendernames/{sender}"
    
    
    
    <?php
    
    function getSender($sender, $token)
    {
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/sms/sendernames/'.$sender);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //hhttps://ssl.smsapi.pl/react/oauth/manage
    $sender = "sender_name";
    
    echo getSender($sender, $token);
    
    ?>
    
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
    {
      "sender":"pole_nadawcy",
      "is_default":false,
      "status":"ACTIVE",
      "created_at":"2020-01-01T00:00:00+02:00"
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
      "message":"Sendername not exists",
      "error":"not_found_sendername",
      "errors":[
        {
          "error":"not_found_sendername",
          "message":"Sendername not exists"
        }]
    }
    
    

    Sprawdzanie statusu pola nadawcy odbywa się przez wysłanie metodą GET danych do adresu połączenia:

    Parametr Opis
    {sender} Nazwa pola nadawcy, którego status ma być sprawdzony

    Listy pól nadawcy

    Funkcja pozwala na wyświetlenie listy pól nadawcy.

    curl -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms/sendernames"
    
    
    
    <?php
    
    function getSenderlist($token)
    {
    
        static $content;
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/sms/sendernames');
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    
    echo getSenderlist($token);
    
    ?>
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.sms.sendernames.Sendernames;
    import pl.smsapi.api.action.sms.sendernames.SendernamesFactory;
    import pl.smsapi.api.action.sms.sendernames.SendernamesList;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class ListSendernames {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SendernamesFactory sendernamesApi = new SendernamesFactory(client, proxy);
    
                SendernamesList action = sendernamesApi.actionList();
    
                Sendernames sendernames = action.execute();
    
                sendernames.list.forEach(sendername -> System.out.println(sendername.sender));
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    {
    "collection":[
        {
            "sender":"pole_nadawcy1",
            "is_default":false,
            "status":"ACTIVE",
            "created_at":"2018-09-23T12:00:00+02:00"
        },
        {
            "sender":"pole_nadawcy2",
            "is_default":true,
            "status":"ACTIVE",
            "created_at":"2019-05-19T16:00:00+02:00"
        },
        {
            "sender":"pole_nadawcy3",
            "is_default":false,
            "status":"INACTIVE",
            "created_at":"2020-01-01T00:30:00+02:00"
        }
    ],
    "size":3
    }
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Authorization failed",
        "error":"authorization_failed",
        "developer_description":null,
        "errors":null
    }
    
    

    Domyślne pole nadawcy

    Funkcja pozwala na ustawienie domyślnego pola nadawcy.

    
    curl -H "Authorization: Bearer token_api_oauth" \
    -X POST "https://api.smsapi.pl/sms/sendernames/{sender}/commands\
    /make_default"
    
    
    
    <?php
    
    function DefaultSendername($token,$sender)
    {
    
        static $content;
    
        $url = 'https://api.smsapi.pl/sms/sendernames/'.$sender.'/commands/make_default';
    
        $c = curl_init();
        curl_setopt($c, CURLOPT_URL, $url);
        curl_setopt($c, CURLOPT_POST, true);
        curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($c, CURLOPT_HTTPHEADER, array(
            "Authorization: Bearer $token"
        ));
    
        $content = curl_exec($c);
    
        curl_close($c);
        return $content;
    }
    
    $token = "token_api_oauth"; //https://ssl.smsapi.pl/react/oauth/manage
    $sender = "sender_name";
    
    echo DefaultSendername($token,$sender);
    
    ?>
    
    
    import pl.smsapi.OAuthClient;
    import pl.smsapi.api.action.sms.sendernames.SendernameMakeDefault;
    import pl.smsapi.api.action.sms.sendernames.SendernamesFactory;
    import pl.smsapi.exception.SmsapiException;
    import pl.smsapi.proxy.ProxyNative;
    
    public class MakeDefaultSendername {
        public static void main(String[] args) {
            try {
                String oauthToken = "00000000000000000000000000000000";
                OAuthClient client = new OAuthClient(oauthToken);
                ProxyNative proxy = new ProxyNative("https://api.smsapi.pl/");
    
                SendernamesFactory sendernamesApi = new SendernamesFactory(client, proxy);
    
                SendernameMakeDefault action = sendernamesApi.actionMakeDefault("default_sender_name");
    
                action.execute();
    
            } catch (SmsapiException e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
    }
    

    Przykładowa odpowiedź:

    a) w przypadku sukcesu:

    
        Zwracany jest tylko kod HTTP204
    
    

    b) w przypadku niepowodzenia:

    
    {
        "message":"Sendername not exists",
        "error":"not_found_sendername",
        "errors":[
            {
                "error":"not_found_sendername",
                "message":"Sendername not exists"
            }
        ]
    }
    
    

    Domyślne pole nadawcy jest to nazwa, z która zostanie wysłana wiadomość w przypadku przesłania parametru &from lub gdy parametr ten jest pusty. Pole nadawcy ustawiane jako domyślne musi być aktywne. W przypadku braku domyślnego pola nadawcy wiadomości takie wysyłane są z nazwą SMSAPI.

    W celu ustawienia nazwy jako domyślne pole nadawcy należy umieścić parametr &default=nazwa, gdzie nazwa jest nazwą pola nadawcy, które ma być domyślnym.

    Parametr Opis
    {sender} Nazwa, która ma być ustawiona jako domyślna

    16. SMS Authenticator

    SMS Authenticator jest implementacją składnika, który może być częścią uwierzytelniania wieloskładnikowego (multi-factor authentication, MFA). Pozwala na uproszczenie operacji autoryzacji użytkownika/klienta. Realizowana jest w dwóch etapach. Pierwszy polega na wysłaniu automatycznie wygenerowanego kodu autoryzacyjnego w wiadomości SMS. W drugim etapie następuje weryfikacja czy kod podany przez odbiorce jest prawidłowy. Wysyłany kod autoryzacyjny jest ważny 180 sekund.

    Wiadomości wysyłane za pomocą SMS Authenticatora domyślnie są wiadomościami typu FAST co wiąże się z kosztami wysyłki x1.5. Jeżeli wiadomości mają być wysyłane bez opcji FAST należy w zapytaniu dodać parametr fast=0.

    Wysyłka kodu

    
    curl -H "Authorization: Bearer token_api_oauth"\
    -H "Content-Type: application/json" -X POST -d\ 
    '{"phone_number":"48500500500","from":"Test","content":"Twój kod: [%code%]","fast":"1"}'\
    https://api.smsapi.pl/mfa/codes
    
    
    
    <?php
    $url = 'https://api.smsapi.pl/mfa/codes';
    $ch = curl_init($url);
    $params = array(
        'phone_number' => '48500500500',         //numer telefonu do wysyłki kodu
        'from'         => 'Test',                //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        'content'      => 'Twój kod: [%code%]',  //treść wiadomości z polem [%code%] (parametr opcjonalny)
        'fast'         => '1'                    //typ wiadomości (domyślnie fast=1)
    );
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Authorization: Bearer token_api_oauth'));
    $result = curl_exec($ch);
    ?>  
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Mfa;
    use Smsapi\Client\Feature\Mfa\Bag\CreateMfaBag;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    $createMfaBag = new CreateMfaBag('48500500500');
    $createMfaBag->from = 'Test';
    $createMfaBag->content = 'Twój kod: [%code%]';
    
    /** @var Mfa $mfa */
    $mfa = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->mfaFeature()
        ->generateMfa($createMfaBag);
    
    var_dump($mfa);
    
    

    Przykładowa odpowiedź:

    {
      "id":"5ADEF4DC3738305BEED02B0C",
      "code":"123456",
      "phone_number":"48500500500",
      "from":"Test"
    }
    

    Wysyłka kodu autoryzacyjnego polega na wygenerowaniu requestu POST do API z numerem telefonu odbiorcy.

    Parametr Opis
    phone_number Numer telefonu odbiocy SMS autoryzacyjnego
    from Pole nadawcy z jakiego wysłany będzie SMS autoryzacyjny. W przypadku braku parametru from, wiadomość zostanie wysłana z domyślnym polem nadawcy dla danego konta
    content Spersonalizowana treść wiadomości autoryzacyjnej z polem [%code%]. W przypadku braku parametru content, wiadomość zostanie wysłana z domyślną treścią
    fast Ustawienie priorytetu wysyłanej wiadomości, domyślnie fast=1 z szybszym doręczeniem wiadomości, opłata x1.5 zwykłej wiadomości

    W odpowiedzi zwracany jest json z następującymi parametrami:

    Parametr Opis
    id ID zdarzenia
    code Kod autoryzacyjny wysłany do odbiorcy
    phone_number Numer telefonu odbiocy SMS autoryzacyjnego (z dodanym prefiksem kraju)
    from Pole nadawcy z jakiego wysłany został SMS autoryzacyjny

    Sprawdzenie poprawności kodu

    
    curl -H "Authorization: Bearer token_api_oauth"\
    -H "Content-Type: application/json" -X POST -i -d\
    '{"phone_number":"48500500500","code":"123456"}'\
    https://api.smsapi.pl/mfa/codes/verifications
    
    
    
    <?php
    $url = 'https://api.smsapi.pl/mfa/codes/verifications';
    $ch = curl_init($url);
    $params = array(
        'phone_number' => '48500500500',    // numer telefonu podającego kod (z prefiksem kraju, w formacie zwróconym przez serwer w poprzednim odwołaniu)
        'code'         => '123456'          // kod do sprawdzenia 
    );
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_HEADER, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Authorization: Bearer token_api_oauth'));
    $result = curl_exec($ch);
    ?>  
    
    
    
    <?php
    
    declare(strict_types=1);
    
    require_once 'vendor/autoload.php';
    
    use Smsapi\Client\Feature\Mfa;
    use Smsapi\Client\Feature\Mfa\Bag\VerificationMfaBag;
    use Smsapi\Client\Curl\SmsapiHttpClient;
    
    /** @var Mfa $mfa */
    $mfa = (new SmsapiHttpClient())
        ->smsapiPlService('token_api_oauth')
        ->mfaFeature()
        ->verifyMfa(new VerificationMfaBag('123456', '48500500500'));
    
    var_dump($mfa);
    
    

    Przykładowa odpowiedź:

    
    HTTP/1.1 204
    
    

    Sprawdzenie poprawności kodu autoryzacyjnego jest realizowane przez podanie dwóch parametrów w requescie POST do API, numeru telefonu odbiorcy oraz kodu autoryzacyjnego wprowadzonego przez użytkownika.

    Parametr Opis
    code Kod autoryzacyjny wprowadzony przez odbiorcę SMS autoryzacyjnego
    phone_number Numer telefonu odbiocy SMS autoryzacyjnego

    W odpowiedzi zwracany jest HTTP CODE obsługujący 3 zdarzenia:

    Status Opis
    204 Poprawny kod
    404 Błędny kod
    408 Przedawniony kod (czas powyżej 180 sekund)

    17. Interfejs SMPP

    Protokół SMPP

    SMPP (Short Message Peer-to-Peer) jest otwartym, ustandaryzowanym protokołem zaprojektowanym do bezpośredniej komunikacji pomiędzy systemami teleinformatycznymi, takimi jak operatorskie Centrum SMS (SMSC) oraz Systemy przesyłania wiadomości SMS (SME/ESME) w celu przesyłu krótkich wiadomości tekstowych SMS. Protokół SMPP wykorzystywany jest w SMSAPI głównie do komunikacji z polskimi sieciami komórkowymi oraz agregatorami SMS dla wysyłek zagranicznych (połączenia ESME <-> SMSC). Dla serwisów posiadających własny rozbudowany system obsługi klientów szukających dostawcy usługi wysyłki wiadomości SMS platforma SMSAPI w razie potrzeby może udostępnić połączenie do własnego SMSC za pomocą interfejsu SMPP.

    Protokół SMPP oparty jest na binarnie zakodowanych parach pakietów zapytań/odpowiedzi (request/response PDUs) przesyłanych za pomocą warstwy transportowej modelu OSI. Dane pomiędzy peer'ami wymieniane mogą być synchronicznie, gdzie po każdym wysłanym pakiecie oczekiwana jest odpowiedź przed wysłaniem kolejnego, oraz asynchroniczne gdzie dozwolone jest wysyłanie większej liczby pakietów bez odpowiedzi potwierdzającej ich odebranie. Dozwolona liczba zapytań bez odpowiedzi, nazywana oknem, powinna być identyczna dla obu stron komunikacji dla zapewnienia najwyższej jakości usługi.

    Sposób komunikacji wykorzystywany w protokole SMPP sprawia, że dla poprawnego wysłania wiadomości SMS nie jest konieczne wykorzystywanie telefonów komórkowych, modemów GSM czy kart SIM. Dodatkowo udostępnia on wiele funkcjonalności niedostępnych przy użyciu standardowych urządzeń komunikacji GSM jak np. przesyłanie wiadomości z alfanumerycznym polem nadawcy zamiast standardowego numeru telefonu.

    Szczegółowe informacje oraz dostęp do połączenia SMPP można uzyskać w Biurze Obsługi Klienta - kontakt

    18. Lista statusów doręczenia

    Kod Status ANG Status Opis
    401 NOT_FOUND Nieznaleziona Błędny numer ID lub raport wygasł
    402 EXPIRED Przedawniona Wiadomość niedostarczona z powodu zbyt długiego czasu niedostępność numeru
    403 SENT Wysłana Wiadomość została wysłana ale operator nie zwrócił jeszcze raportu doręczenia
    404 DELIVERED Dostarczona Wiadomość dotarła do odbiorcy
    405 UNDELIVERED Niedostarczona Wiadomość niedostarczona (np.: błędny numer, numer niedostępny)
    406 FAILED Nieudana Błąd podczas wysyłki wiadomości - prosimy zgłosić
    407 REJECTED Odrzucona Wiadomość niedostarczona (np.: błędny numer, numer niedostępny)
    408 UNKNOWN Nieznany Brak raportu doręczenia dla wiadomości (wiadomość doręczona lub brak możliwości doręczenia)
    409 QUEUE Kolejka Wiadomość czeka w kolejce na wysyłkę
    410 ACCEPTED Zaakceptowana Wiadomość przyjęta przez operatora
    411 RENEWAL Ponawianie Wykonana była próba połączenia która nie została odebrana, połączenie zostanie ponowione.
    412 STOP Zatrzymanie Zatrzymanie

    19. Kody błędów

    ERROR Opis
    7 Skrócone linki są wyłączone na koncie
    8 Błąd w odwołaniu (Prosimy zgłosić)
    11 Zbyt długa lub brak wiadomości lub ustawiono parametr nounicode i pojawiły się znaki specjalne w wiadomości. Dla wysyłki VMS błąd oznacz brak pliku WAV lub błąd tekstu TTS (brak tekstu lub inne niż UTF-8 kodowanie).
    12 Wiadomość składa się z większej ilości części niż określono w parametrze &max_parts
    13 Brak prawidłowych numerów telefonów (numer błędny, stacjonarny (w przypadku wysyłki SMS) lub znajdujący się na czarnej liście)
    14 Nieprawidłowe pole nadawcy
    17 Nie można wysłać FLASH ze znakami specjalnymi
    18 Nieprawidłowa liczba parametrów
    19 Za dużo wiadomości w jednym odwołaniu (zbyt duża liczba odbiorców, w przypadku użycia skróconego linku, limit wynosi 100)
    20 Nieprawidłowa liczba parametrów IDX
    21 Wiadomość MMS ma za duży rozmiar (maksymalnie 300kB)
    22 Błędny format SMIL
    23 Błąd pobierania pliku dla wiadomości MMS lub VMS
    24 Błędny format pobieranego pliku
    25 Parametry &normalize oraz &datacoding nie mogą być używane jednocześnie.
    26 Za długi temat wiadomości. Temat może zawierać maksymalnie 30 znaków.
    27 Parametr IDX za długi. Maksymalnie 255 znaków
    28 Błędna wartość parametru time_restriction. Dostępne wartości to follow, ignore lub nearest_available
    30 Brak parametru UDH jak podany jest datacoding=bin
    31 Błąd konwersji TTS
    32 Nie można wysyłać wiadomości MMS i VMS na zagraniczne numery lub wysyłka na zagranicę wyłączona na koncie.
    33 Brak poprawnych numerów
    35 Błędna wartość parametru tts_lector. Dostępne wartości: agnieszka, ewa, jacek, jan, maja
    36 Nie można wysyłać wiadomości binarnych z ustawioną stopką.
    37 Wiadomość TTS jest zbyt długa
    40 Brak grupy o podanej nazwie
    41 Wybrana grupa jest pusta (brak kontaktów w grupie)
    50 Nie można zaplanować wysyłki na więcej niż 3 miesiące w przyszłość
    51 Ustawiono błędną godzinę wysyłki, wiadomość VMS mogą być wysyłane tylko pomiędzy godzinami 8 a 22 lub ustawiono kombinację parametrów try i interval powodującą możliwość próby połączenia po godzinie 22.
    52 Za dużo prób wysyłki wiadomości do jednego numeru (maksymalnie 10 prób w przeciągu 60sek do jednego numeru)
    53 Nieunikalny parametr idx. Wiadomość o podanym idx została wysłana w ostatnich czterech dniach lub jest zaplanowana do wysyłki w przyszłości przy wykorzystaniu parametru &check_idx=1.
    54 Błędny format daty. Ustawiono sprawdzanie poprawności daty &date_validate=1
    55 Brak numerów stacjonarnych w wysyłce i ustawiony parametr skip_gsm
    56 Różnica pomiędzy datą wysyłki, a datą wygaśnięcia nie może być mniejsza niż 15 minut i większa niż 72 godzin
    57 Numer znajduje się na czarnej liście dla danego użytkownika.
    59 Numer znajduje się na liście "Wypisani"
    60 Grupa kodów o podanej nazwie nie istnieje.
    61 Data ważności grupy kodów minęła.
    62 Brak wolnych kodów w podanej grupie (wszystkie kody zostały już wykorzystane).
    65 Brak wystarczającej liczby kodów rabatowych dla wysyłki. Liczba niewykorzystanych kodów w grupie musi być co najmniej równa liczbie numerów w wysyłce.
    66 W treści wiadomości brak jest znacznika [%kod%] dla wysyłki z parametrem &discount_group (znacznik taki jest wymagany).
    70 Błędny adres CALLBACK w parametrze notify_url.
    74 Data wysyłki nie spełnia ograniczeń czasowych ustawionych na koncie
    76 Nieprawidłowe znaki w parametrach żądania
    94 Wysyłka wiadomości z linkiem jest zablokowana
    96 Limit wysyłek na koncie dla kraju został osiągnięty
    98 Twoje konto jest ograniczone. Możesz wysyłać wiadomości tylko na numer użyty podczas rejestracji.
    101 Niepoprawne lub brak danych autoryzacji
    102 Nieprawidłowy login lub hasło
    103 Brak punktów dla tego użytkownika
    104 Brak szablonu
    105 Błędny adres IP (włączony filtr IP dla interfejsu API)
    106 Błędny adres URL do skrócenia w parametrze [%idzdo:adres_URL%]
    110 Usługa (SMS, MMS, VMS lub HLR) nie jest dostępna na danym koncie.
    112 Wysyłka wiadomości na numery telefonów w tym kraju jest zablokowana na koncie.
    200 Nieudana próba wysłania wiadomości, prosimy ponowić odwołanie
    201 Wewnętrzny błąd systemu (prosimy zgłosić)
    202 Zbyt duża ilość jednoczesnych odwołań do serwisu, wiadomość nie została wysłana (prosimy odwołać się ponownie)
    203 Zbyt wiele odwołań do serwisu. Spróbuj ponownie później. Dotyczy endpointu https://api.smsapi.pl/subusers
    300 Nieprawidłowa wartość pola points (przy użyciu pola points jest wymagana wartość 1)
    301 Wiadomość o podanym ID nie istnieje lub jest zaplanowana do wysłania w przeciągu najbliższych 60 sekund (nie można usunąć takiej wiadomości).
    400 Nieprawidłowy ID statusu wiadomości.
    401 Token nie ma uprawnień do wykonywanej akcji.
    409 Podana wartość już istnieje.
    997 Żądania HTTP zostały wyłączone na Twoim koncie, prosimy o używanie bezpiecznego połączenia (HTTPS)
    998 Usługa idz.do nie jest dostępna
    999 Wewnętrzny błąd systemu (prosimy zgłosić)
    1000 Akcja dostępna tylko dla użytkownika głównego
    1001 Nieprawidłowa akcja (oczekiwane jedna z add_user, set_user, get_user, credits)
    1010 Błąd dodawania użytkownika
    1020 Błąd edycji konta użytkownika
    1021 Brak danych do edycji, przynajmniej jeden parametr musi być edytowany
    1030 Błąd pobierania danych użytkownika
    1032 Nie istnieje użytkownik o podanej nazwie dla danego użytkownika głównego
    1100 Błąd danych użytkownika
    1110 Błędna nazwa tworzonego użytkownika
    1111 Nie podano nazwy tworzonego konta użytkownika
    1112 Nazwa konta użytkownika za krótka (minimum 3 znaki)
    1113 Nazwa konta użytkownika za długa, łączna długość nazwy użytkownika wraz z prefiksem użytkownika głównego może mieć maksymalnie 32 znaki
    1114 W nazwie użytkownika pojawiły się nidozwolone znaki, dozwolone są litery [A – Z], cyfry [0 – 9] oraz znaki @, -, _ i
    1115 Istnieje już użytkownik o podanej nazwie
    1120 Błąd hasła dla tworzonego konta użytkownika
    1121 Hasło dla tworzonego konta użytkownika za krótkie
    1122 Hasło dla tworzonego konta użytkownika za długie
    1123 Hasło powinno być zakodowane w MD5
    1130 Błąd limitu punktów przydzielanego użytkownikowi
    1131 Parametr limit powinno zawierać wartość numeryczną
    1140 Błąd limitu miesięcznego punktów przydzielanego użytkownikowi
    1141 Parametr month_limit powinno zawierać wartość numeryczną
    1150 Błędna wartość parametru senders, dopuszczalne wartości dla tego parametru to 0 lub 1
    1160 Błędna wartość parametru phonebook, dopuszczalne wartości dla tego parametru to 0 lub 1
    1170 Błędna wartość parametru active, dopuszczalne wartości dla tego parametru to 0 lub 1
    1180 Błąd parametru info
    1183 Zawartość parametru info jest za długa
    1190 Błąd hasła do interfejsu API dla konta użytkownika
    1192 Błędna długość hasła do interfejsu API dla konta użytkownika (hasło zakodowane w md5 powinno mieć 32 znaki)
    1193 Hasło do interfejsu powinno zostać podane w formie zakodowanej w md5
    2001 Nieprawidłowa akcja (oczekiwane jedna z add, status, delete, list)
    2010 Błąd dodawania pola nadawcy
    2030 Błąd sprawdzania statusu pola nadawcy
    2031 Nie istnieje pole nadawcy o podanej nazwie
    2060 Błąd dodawania domyślnego pola nadawcy
    2061 Pole nadawcy musi być aktywne, żeby ustawić je jako domyślne
    2062 Pole nadawcy już jest ustawione jako domyślne
    2100 Błąd przesyłanych danych
    2110 Błąd nazwy pola nadawcy
    2111 Brak nazwy dodawanego pola nadawcy (parametr &add jest pusty)
    2112 Niepoprawna nazwa pola nadawcy (np. numer telefonu, zawierająca polskie i/lub specjalne znaki lub za długie), pole nadawcy może mieć maksymalnie 11 znaków, dopuszczalne znaki: a-z A-Z 0-9 - . [spacja]
    2115 Pole o podanej nazwie już istnieje

    Kody błędów HLR

    Tabela błędów systemu HLR:

    Błąd Opis
    UNKNOWN_SUBSCRIBER Błędny, nieaktywny numer. Błąd mający charakter stały.
    ABSENT_SUBSCRIBER Numer wyłączony lub poza zasięgiem przez dłuższy czas. Numer uznany jest jako nieaktywny (podobnie jak w przypadku UNKNOWN) jednak ma charakter tymczasowy, jeżeli numer pojawi się w zasięgu stanie się na nowo aktywny.
    TELESERVICE_NOT_PROVISIONED Numer ma zablokowaną opcję odbierania wiadomości SMS. Błąd ma charakter stały.
    SYSTEM_FAILURE Błąd systemu sieci macierzystej podczas sprawdzania numeru, ma charakter tymczasowy.
    HLR_LOCAL_CANCEL / HLR_ABORT Błąd sytemu HLR dla danego numeru, ma charakter tymczasowy.
    CALL_BARRED Zablokowane połączenia przychodzące dla danego numeru. Błąd ma charakter stały

    20. Alfabet 7bit GSM

    Tutaj przedstawiony jest podstawowy alfabet '7bit' zgodny ze specyfikacją GSM 03.38.

    Wszystkie znaki poza tym spisem, są uznawane za znaki specjalne oraz skracają wiadomość ze 160 znaków na 70. Użycie znaków z tej listy nie skróci wiadomości.

    Zauważ, że znaki ^ { } [ ] \ ~ | € są liczone podwójnie, kiedy wysyłana jest wiadomość bez znaków specjalnych z powodu wymagań specyfikacji GSM.

    Znak Nazwa Znaku HEX DEC
    @ COMMERCIAL AT 0x00 0
    £ POUND SIGN 0x01 1
    $ DOLLAR SIGN 0x02 2
    ¥ YEN SIGN 0x03 3
    è LATIN SMALL LETTER E WITH GRAVE 0x04 4
    é LATIN SMALL LETTER E WITH ACUTE 0x05 5
    ù LATIN SMALL LETTER U WITH GRAVE 0x06 6
    ì LATIN SMALL LETTER I WITH GRAVE 0x07 7
    ò LATIN SMALL LETTER O WITH GRAVE 0x08 8
    Ç LATIN CAPITAL LETTER C WITH CEDILLA 0x09 9
    LINE FEED 0x0A 10
    Ø LATIN CAPITAL LETTER O WITH STROKE 0x0B 11
    ø LATIN SMALL LETTER O WITH STROKE 0x0C 12
    CARRIAGE RETURN 0x0D 13
    Å LATIN CAPITAL LETTER A WITH RING ABOVE 0x0E 14
    å LATIN SMALL LETTER A WITH RING ABOVE 0x0F 15
    Δ GREEK CAPITAL LETTER DELTA 0x10 16
    _ LOW LINE 0x11 17
    Φ GREEK CAPITAL LETTER PHI 0x12 18
    Γ GREEK CAPITAL LETTER GAMMA 0x13 19
    Λ GREEK CAPITAL LETTER LAMBDA 0x14 20
    Ω GREEK CAPITAL LETTER OMEGA 0x15 21
    Π GREEK CAPITAL LETTER PI 0x16 22
    Ψ GREEK CAPITAL LETTER PSI 0x17 23
    Σ GREEK CAPITAL LETTER SIGMA 0x18 24
    Θ GREEK CAPITAL LETTER THETA 0x19 25
    Ξ GREEK CAPITAL LETTER XI 0x1A 26
    ESCAPE TO EXTENSION TABLE 0x1B 27
    FORM FEED 0x1B0A 27 10
    ^ CIRCUMFLEX ACCENT 0x1B14 27 20
    { LEFT CURLY BRACKET 0x1B28 27 40
    } RIGHT CURLY BRACKET 0x1B29 27 41
    '\' REVERSE SOLIDUS (BACKSLASH) 0x1B2F 27 47
    [ LEFT SQUARE BRACKET 0x1B3C 27 60
    ~ TILDE 0x1B3D 27 61
    ] RIGHT SQUARE BRACKET 0x1B3E 27 62
    VERTICAL BAR 0x1B40 27 64
    EURO SIGN 0x1B65 27 101
    Æ LATIN CAPITAL LETTER AE 0x1C 28
    æ LATIN SMALL LETTER AE 0x1D 29
    ß LATIN SMALL LETTER SHARP S (German) 0x1E 30
    É LATIN CAPITAL LETTER E WITH ACUTE 0x1F 31
    SPACE 0x20 32
    ! EXCLAMATION MARK 0x21 33
    \" QUOTATION MARK 0x22 34
    # NUMBER SIGN 0x23 35
    ¤ CURRENCY SIGN 0x24 36
    % PERCENT SIGN 0x25 37
    & AMPERSAND 0x26 38
    ' APOSTROPHE 0x27 39
    ( LEFT PARENTHESIS 0x28 40
    ) RIGHT PARENTHESIS 0x29 41
    * ASTERISK 0x2A 42
    + PLUS SIGN 0x2B 43
    , COMMA 0x2C 44
    - HYPHEN-MINUS 0x2D 45
    . FULL STOP 0x2E 46
    / SOLIDUS (SLASH) 0x2F 47
    0 DIGIT ZERO 0x30 48
    1 DIGIT ONE 0x31 49
    2 DIGIT TWO 0x32 50
    3 DIGIT THREE 0x33 51
    4 DIGIT FOUR 0x34 52
    5 DIGIT FIVE 0x35 53
    6 DIGIT SIX 0x36 54
    7 DIGIT SEVEN 0x37 55
    8 DIGIT EIGHT 0x38 56
    9 DIGIT NINE 0x39 57
    : COLON 0x3A 58
    ; SEMICOLON 0x3B 59
    < LESS-THAN SIGN 0x3C 60
    = EQUALS SIGN 0x3D 61
    > GREATER-THAN SIGN 0x3E 62
    ? QUESTION MARK 0x3F 63
    ¡ INVERTED EXCLAMATION MARK 0x40 64
    A LATIN CAPITAL LETTER A 0x41 65
    B LATIN CAPITAL LETTER B 0x42 66
    C LATIN CAPITAL LETTER C 0x43 67
    D LATIN CAPITAL LETTER D 0x44 68
    E LATIN CAPITAL LETTER E 0x45 69
    F LATIN CAPITAL LETTER F 0x46 70
    G LATIN CAPITAL LETTER G 0x47 71
    H LATIN CAPITAL LETTER H 0x48 72
    I LATIN CAPITAL LETTER I 0x49 73
    J LATIN CAPITAL LETTER J 0x4A 74
    K LATIN CAPITAL LETTER K 0x4B 75
    L LATIN CAPITAL LETTER L 0x4C 76
    M LATIN CAPITAL LETTER M 0x4D 77
    N LATIN CAPITAL LETTER N 0x4E 78
    O LATIN CAPITAL LETTER O 0x4F 79
    P LATIN CAPITAL LETTER P 0x50 80
    Q LATIN CAPITAL LETTER Q 0x51 81
    R LATIN CAPITAL LETTER R 0x52 82
    S LATIN CAPITAL LETTER S 0x53 83
    T LATIN CAPITAL LETTER T 0x54 84
    U LATIN CAPITAL LETTER U 0x55 85
    V LATIN CAPITAL LETTER V 0x56 86
    W LATIN CAPITAL LETTER W 0x57 87
    X LATIN CAPITAL LETTER X 0x58 88
    Y LATIN CAPITAL LETTER Y 0x59 89
    Z LATIN CAPITAL LETTER Z 0x5A 90
    Ä LATIN CAPITAL LETTER A WITH DIAERESIS 0x5B 91
    Ö LATIN CAPITAL LETTER O WITH DIAERESIS 0x5C 92
    Ñ LATIN CAPITAL LETTER N WITH TILDE 0x5D 93
    Ü LATIN CAPITAL LETTER U WITH DIAERESIS 0x5E 94
    § SECTION SIGN 0x5F 95
    ¿ INVERTED QUESTION MARK 0x60 96
    a LATIN SMALL LETTER A 0x61 97
    b LATIN SMALL LETTER B 0x62 98
    c LATIN SMALL LETTER C 0x63 99
    d LATIN SMALL LETTER D 0x64 100
    e LATIN SMALL LETTER E 0x65 101
    f LATIN SMALL LETTER F 0x66 102
    g LATIN SMALL LETTER G 0x67 103
    h LATIN SMALL LETTER H 0x68 104
    i LATIN SMALL LETTER I 0x69 105
    j LATIN SMALL LETTER J 0x6A 106
    k LATIN SMALL LETTER K 0x6B 107
    l LATIN SMALL LETTER L 0x6C 108
    m LATIN SMALL LETTER M 0x6D 109
    n LATIN SMALL LETTER N 0x6E 110
    o LATIN SMALL LETTER O 0x6F 111
    p LATIN SMALL LETTER P 0x70 112
    q LATIN SMALL LETTER Q 0x71 113
    r LATIN SMALL LETTER R 0x72 114
    s LATIN SMALL LETTER S 0x73 115
    t LATIN SMALL LETTER T 0x74 116
    u LATIN SMALL LETTER U 0x75 117
    v LATIN SMALL LETTER V 0x76 118
    w LATIN SMALL LETTER W 0x77 119
    x LATIN SMALL LETTER X 0x78 120
    y LATIN SMALL LETTER Y 0x79 121
    z LATIN SMALL LETTER Z 0x7A 122
    ä LATIN SMALL LETTER A WITH DIAERESIS 0x7B 123
    ö LATIN SMALL LETTER O WITH DIAERESIS 0x7C 124
    ñ LATIN SMALL LETTER N WITH TILDE 0x7D 125
    ü LATIN SMALL LETTER U WITH DIAERESIS 0x7E 126
    à LATIN SMALL LETTER A WITH GRAVE 0x7F 127

    Dopuszczalna liczba znaków w wiadomościach:

    Liczba części Bez znaków specjalnych Ze znakami specjalnymi
    1 część 160 znaków 70 znaków
    2 części 306 znaków 134 znaków
    3 części 459 znaków 201 znaków
    4 części 612 znaków 268 znaków
    5 części 765 znaków 335 znaków
    6 części 918 znaków 402 znaków
    7 części 1071 znaków 469 znaków
    8 części 1224 znaków 536 znaków
    9 części 1377 znaków 603 znaków
    10 części 1530 znaków 670 znaków

    21. Kodowanie

    Przykład:

    curl -H "Authorization: Bearer token_api_oauth" \
    "https://api.smsapi.pl/sms.do?\
    from=pole_nadawcy&\
    to=48500000000&\
    encoding=utf-8&\
    message=treść_wiadomości"
    
    <?php
    
    $params = [
        'to' => '48500000000',
        'message' => "Hello world!",
        'encoding' => 'utf-8'
    ];
    
    $c = curl_init();
    curl_setopt($c, CURLOPT_URL, 'https://api.smsapi.pl/sms.do');
    curl_setopt($c, CURLOPT_POST, true);
    curl_setopt($c, CURLOPT_POSTFIELDS, $params);
    curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($c, CURLOPT_HTTPHEADER, ["Authorization: Bearer %SMSAPI_ACCESS_TOKEN%"]);
    curl_exec($c);
    

    Domyślnie kodowanie znaków ustawione jest na windows-1250. Jednak do wysyłania wiadomości można użyć jednego z poniżej przedstawionych rodzajów kodowania. W tym celu wykorzystać należy parametr &encoding.

    22. Integracje

    Branża e-commerce coraz częściej i chętniej korzysta z potencjału mobilnej komunikacji, tym bardziej, że przekłada się ona zarówno na wprowadzenie oszczędności, jak i wsparcie sprzedaży.

    Z SMSAPI zintegrowanych jest już kilkadziesiąt platform tworzących oprogramowania e-sklepów, CRM oraz wielu innych. Ich pełną listę znajdziesz tutaj.

    Gmail

    Skrypt monitoruje wiadomości na podstawie etykiet. Aby ustawić automatyczne przypisywanie etykiety od zdefiniowanego odbiorcy, należy zalogować się na pocztę Gmail, następnie kliknąć w ikonę koła zębatego znajdującą się w prawym górnym rogu strony i przejść do ustawień

    Ustawienia poczty Gmail potrzebne do integracji z SMSAPI

    W ustawieniach należy przejść do zakładki „Filtry”, a następnie wybrać opcję „utwórz nowy filtr”

    Ustawienia filtrów w Gmail

    W następnym kroku należy określić parametry, dla których danej wiadomości zostanie przypisana odpowiednia etykieta. W tym przypadku powiadomienia będą wysyłane na odebrane wiadomości z adresu bok@smsapi.pl Oznacza to, że wszystkie wiadomości od zdefiniowanego odbiorcy będą automatycznie zapisywane z wybraną etykietą.

    Utworzenie filtrów z etykietą SMSAPI w Gmail

    Aby przejść dalej, należy kliknąć w link „Utwórz filtr na podstawie tych kryteriów wyszukiwania”

    Należy zaznaczyć opcję „zastosuj etykietę”, a następnie stworzyć nową, lub wybrać wcześniej utworzoną

    Utworzenie filtrów z etykietą SMSAPI w Gmail

    Gmail konfiguracja skryptu

    
    function SMSapi() {
    
      // Konfiguracja
      /*******************************************************/
    
      var MAIL_LABEL = 'SMSAPI'; // etykieta (w Gmail) dla której zostanie zrealizowana wysyłka powiadomień SMS
    
      var SMSAPI_TOKEN = 'token_api_oauth';
    
    
      var SMSAPI_SENDERNAME = 'Test';     // pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
      var SMSAPI_RECIVER  = 'tel_number'; // odbiorca wiadomości SMS
    
      var MESSAGE = 'New email from: :SENDER, topic: :TITLE'; // treść wiadomości SMS z dodatkowymi parametrami :SENDER, :TITLE
     /*******************************************************/
    
      var threads = GmailApp.getUserLabelByName(MAIL_LABEL).getThreads();
    
      for(i in threads)
        UrlFetchApp.fetch('https://api.smsapi.pl/sms.do?encoding=utf-8&access_token='+SMSAPI_TOKEN+'&from='+SMSAPI_SENDERNAME+'&to='+encodeURIComponent(SMSAPI_RECIVER)+"&message="+encodeURIComponent(MESSAGE.replace(':SENDER',threads[i].getMessages()[0].getFrom()).replace(':TITLE', threads[i].getMessages()[0].getSubject())));
    
      GmailApp.getUserLabelByName(MAIL_LABEL).removeFromThreads(threads);
    
    }
    
    

    Wymagane zmienne wraz z opisem:

    
      * MAIL_LABEL – nazwa etykiety po której następuje filtrowanie wiadomości email do powiadomień SMS
      * SMSAPI_TOKEN – token w serwisie SMSAPI
      * SMSAPI_SENDERNAME – pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
      * SMSAPI_RECIVER – numer telefonu odbiorcy
      * MESSAGE – treść wiadomości
    
    

    Aby dokonać konfiguracji usługi SMSAPI w Google Mail należy upewnić się czy jesteśmy zalogowani na odpowiednim koncie w usłudze Google a następnie przejść pod adres https://script.google.com

    Witryna Google Script

    Tworzenie nowego skryptu w Google Scripts

    W nowo otwartym oknie usuwamy przykład rozpoczętego skryptu oraz wklejamy skrypt dostępny w naszej dokumentacji.

    W celu ustawienia częstotliwości wykonywania skryptu należy wybrać Ustawienie częstotliwości wykonywania skryptu w Google Calendar w integracji z SMSAPI (wyzwalacze bieżącego projektu) a następnie dodać nowy wyzwalacz i wybrać częstotliwość wyzwalania

    Ustawienia wyzwalacza bieżącego projektu

    Do poprawnego uruchomienia skryptu wymagane jest nadanie mu uprawnień. Skrypt pobiera informacje o adresach e-mail nadawców wiadomości oraz ich tematach dla zdefiniowanej w ustawieniach poczty Gmail etykiety. Następnie wykonywane są odpowiednio przygotowane odwołania do naszego API które skutkują wysłaniem powiadomienia SMS

    Autoryzacja skryptu SMSAPI w Google Mail

    Ustawienia preferencji dostępu SMSAPI do Google Calendar

    Google Calendar

    
    function SmsApiCalendar()
    {
      /* Configuration */
    
      var SMSAPI_TOKEN   = 'token';
    
      var SMSAPI_RECEIVER   = '48XXXXXXXXX'; // Numer odbiorcy
      var SMSAPI_SENDERNAME = 'Test';        //pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
    
      var SMSAPI_URL     = 'https://api.smsapi.pl/sms.do?';
    
      var HOURS = 0;
      var MINUTES  = 30;
      var MESSAGE = 'GOOGLE Calendar: Coming events: :TITLE that begin :TIME';
      /****************/
    
      SMSAPI_URL += 'access_token='+SMSAPI_TOKEN;
      SMSAPI_URL += '&from='+SMSAPI_SENDERNAME;
      SMSAPI_URL += '&to='+encodeURIComponent(SMSAPI_RECEIVER);
    
      var period = (HOURS * 3600000) + (MINUTES * 60000);
      var now = new Date();
      var periodFromNow = new Date(now.getTime() + period);
    
      var calendar = CalendarApp.getDefaultCalendar(); // dla domyślnego kalendarza na koncie
      // lub
      // var calendar = CalendarApp.getCAlendarsByName('nazwa_kalendarza')      dla określonego kalendarza
      var events = calendar.getEvents(now, periodFromNow);
    
      for (var i in events) {
        var event = events[i];
    
        var has_smsapi_status = false;
        var tag_keys = event.getAllTagKeys();
        for (var k = 0; k < tag_keys.length; ++k) {
          if (tag_keys[k] === 'smsapi_status') {
            has_smsapi_status = true;
            break;
          }
        }
    
        if (has_smsapi_status) {
          if (event.getTag('smsapi_status') === 'ok') {
            continue;
          }
        }
        var idx = event.getId();
        var message = MESSAGE.replace(':TITLE', event.getTitle()).replace(':TIME', event.getStartTime());
        var url = SMSAPI_URL+"&encoding=utf8&message="+encodeURIComponent(message)+"&check_idx=1&idx="+encodeURIComponent(idx);
        UrlFetchApp.fetch(url);
        event.setTag('smsapi_status', 'ok');
      }
    }
    
    

    Wymagane zmienne wraz z opisem:

    
        * 'SMSAPI_TOKEN' - token smsAPI
        * 'SMSAPI_RECIVER' - numer odbiorczy
        * 'SMSAPI_SENDERNAME' - pole nadawcy stworzone w https://ssl.smsapi.pl/sms_settings/sendernames
        * 'HOURS' - ustawienie ile godzin przed wydarzeniem ma zostać wysłana wiadomość
        * 'MINUTES' - ustawienie ile minut przed wydarzeniem ma zostać wysłana wiadomość
        * 'MESSAGE' - treść wiadomości SMS
        * ':TITLE' - tytuł wydarzenia
        * ':TIME' czas wydarzenia
    
    

    Integracja pozwala na konfigurację automatycznych powiadomień SMS o nadchodzących wydarzeniach w Kalendarzu Google. W celu rozpoczęcia współpracy należy utworzyć konto w serwisie SMSAPI. Utworzone konto jest gotowe do użytku, jednak zalecamy ustawienie własnego pola nadawcy. Jako domyślne ustawione jest pole nadawcy „Info”. Dodanie pola nadawcy jest usługą całkowicie darmową.

    Aby dokonać konfiguracji usługi SMSAPI w Kalendarzu Google należy upewnić się czy jesteśmy zalogowani na odpowiednim koncie w usłudze Google. Następnie przejść na stronę Google Script

    Witryna Google Script służąca konfirugracji integracji SMSAPI

    Tworzenie nowego skryptu w Google Scripts

    Zmień nazwę z 'Code.gs' na 'SmsApiCalendar.gs'.

    W nowo otwartym oknie usuwamy przykład rozpoczętego skryptu oraz wklejamy skrypt dostępny po prawej ->

    Aby ustawić częstotliwość wykonywania skryptu należy wybrać „Current project's triggers” Click , następnie „No triggers set up. Click here to add one now” oraz zmienić ustawienia na „Minutes timer” i „Every minute”.

    Ustawienie częstotliwośi wykonywania skryptu w Google Calendar w integracji z SMSAPI

    Ustawienia preferencji dostępu SMSAPI do Google Calendar

    Do poprawnego uruchomienia skryptu wymagane jest nadanie mu uprawnień. Skrypt pobiera informacje o datach oraz nazwach wydarzeń w Kalendarzu Google. Następnie wykonywane są odpowiednio przygotowane odwołania do naszego API które skutkują wysłaniem powiadomienia SMS.

    IAI Shop

    Integracja SMSAPI z IAI-SHOP pozwala na wysyłkę powiadomień SMS podczas zmiany statusu zamówienia w sklepie IAI-SHOP oraz powiadomienie właściciela sklepu o nowym zamówieniu. W ramach jednego użytkownika IAI-SHOP można skonfigurować usługę powiadomień SMS dla kilku sklepów.

    Konfiguracja integracji dostępna jest pod adresem iaishop.smsapi.pl Aby uruchomić usługę należy wypełnić formularz pod adresem iaishop.smsapi.pl Rejestracja

    Tworzenie konta w SMSAPI z IAI-SHOP

    Podajemy nazwę użytkownika w SMSAPI („SMSAPI UŻYTKOWNIK”), hasło do API („SMSAPI hasło do API w MD5”).Hasło można wygenerować w panelu klienta pod linkiem SMSAPI

    Podajemy nazwę sklepu IAI-SHOP („IAI-SHOP nazwa sklepu”), nazwę użytkownika IAI-Shop („IAI-SHOP użytkownik”) oraz hasło użytkownika IAI-Shop („IAI-SHOP hasło”).

    Wprowadzone ustawienia należy potwierdzić naciskając „Utwórz konto”.

    Pod adresem iaishop.smsapi.pl Logowanie dostępne jest logowanie do nowo utworzonej integracji z IAI-SHOP

    Logowanie do panelu integracji SMSAPI z IAI_SHOP

    W integracji dostępne są 3 zakładki:

    „Zarządzaj sklepem”, pozwala na konfigurację treści wysyłanym wiadomości SMS podczas zmiany statusu w sklepie IAI-SHOP oraz konfigurację powiadomień o nowym zamówieniu dla właściciela sklepu.

    „Ustawienia SMSAPI”, pozwala na zmianę konta w SMSAPI z którym powiązana jest integracja.

    „Stan konta”, pozwala na sprawdzenie ilości dostępnych punktów na platformie SMSAPI.

    Ustawienia integracji SMSAPI z IAI-SHOP

    Szczegółowa konfiguracja integracji IAI-SHOP

    W zakładce „Zarządzaj sklepem” można wybrać sklep IAI-SHOP dla którego chcemy przeprowadzić konfigurację.

    Na liście „Nadawca wiadomości” można dokonać wyboru pola nadawcy wiadomości SMS spośród dostępnych oraz aktywnych w serwisie SMSAPI.

    Opcja „Zastąp znaki specjalne” pozwala na automatyczną zmianę wszystkich znaków specjalnych ( w tym polskich diakrytycznych) w treści wysyłanych powiadomień SMS na odpowiedniki np. ą na a.

    Opcja „Wyślij fast” pozwala na nadanie wysyłanym wiadomością najwyższego priorytetu zgodnie z wykorzystywanym kanałem PRO. Opcja wiąże się z podwyższonymi opłatami – 1,5x stawki standardowej wiadomości danego typu.

    Opcja „Numer właściciela sklepu” pozwala na konfigurację numeru/ów na które zostaną wysłane powiadomienia SMS o nowym zamówieniu

    Zarządzanie integracją SMSAPI z IAI-SHOP

    Opcja przedstawiona poniżej pozwala na aktywacje wysyłki oraz konfigurację treści powiadomienia SMS o nowym zamówieniu.

    Konfiguracja treści powiadomienia SMS o nowym zamówieniu w IAI-SHOP

    Opcja przedstawiona poniżej pozwala na aktywacje wysyłki oraz konfigurację treści powiadomień SMS o zmianie statusu zamówienia w sklepie IAI-SHOP.

    Konfiguracja treści powiadomienia SMS o zmianie zamówienia w IAI-SHOP

    Tabela dostępnych parametrów w treści powiadomień SMS dla integracji z IAI-SHOP:

    Parametr Opis
    {customer} Imię i nazwisko klienta
    {number} Numer zamówienia
    {phone} Numer telefonu klienta
    {status} Status zamówienia klienta
    {total_price} Całkowita wartość zamówienia

    QNAP

    Aby skonfigurować serwer QNAP do wysyłania powiadomień, należy przejść do zakładki Ustawienia systemowe → Powiadomienia →Serwer SMSC.

    Konfiguracja serwera QNAP

    W polu Usługodawca SMS należy wybrać opcję Dodaj usługodawcę SMS.

    Do pola poniżej należy wpisać swoją nazwę – np. SMSAPI.pl

    Do pola Szablon tekstowy URL należy wkleić poniższe wyrażenie:

    https://api.smsapi.pl/sms.do?username=@@UserName@@&password=@@Password@@&to=@@PhoneNumber@@&from=Test&message=@@Text@@

    Następnie należy wybrać przycisk Zapisz

    W kolejnym kroku należy wybrać z listy wyboru przed chwilą utworzoną konfigurację - SMSAPI.pl

    Wybór utworzonej integracji SMSAPI w QNAP

    W polu Nazwa użytkownika serwera SMS powinien się znaleźć Państwa login z serwisu SMSAPI

    Do pola Hasło użytkownika serwera SMS należy wpisać zakodowane hasło w md5.

    W zakładce Ustawienia systemowe → Powiadomienia → Powiadomienia o alertach należy zaznaczyć opcję SMS

    Ustawienia alertów SMS w QNAP

    W kolejnym kroku należy wybrać kraj oraz numery telefonów (maksymalnie dwa) na jakie mają być wysyłane powiadomienia o błędach.

    Ustawienia alertów SMS w QNAP

    Autoryzacja OAuth2 Webflow

    OAuth - metoda autoryzacji umożliwiająca integrację aplikacji zewnętrznych z SMSAPI. Przed rozpoczęciem procesu integracji prosimy o kontakt na adres e-mail tech@smsapi.pl w celu przydzielenia client_id i client_secret.

    Przykład pierwszego kroku autoryzacji (użytkownik jest przekierowywany do SMSAPI, gdzie musi się zalogować i zatwierdzić integrację):

    https://ssl.smsapi.pl/oauth/access?client_id=123456&redirect_uri=https://www.sample.pl/&scope=sms mms hlr
    

    Przykładowa odpowiedź:

    https://www.sample.pl/?code=11112222
    

    W pierwszym kroku autoryzacji użytkownik jest przekierowywany do panelu SMSAPI, gdzie musi się zalogować i zatwierdzić integrację. Po otrzymaniu pozytywnej weryfikacji użytkownik zostaje przekierowany na stronę podaną w parametrze redirect_uri i otrzymuje swój code, który należy podać w drugim kroku.

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    redirect_uri Adres URL, na który zostanie przekierowany użytkownik po autoryzacji
    scope Zdefiniowane uprawnienia do funkcjonalności
    state Opcjonalny parametr - token CSRF

    Dostępne parametry scope:

    Parametr Opis
    sms Dostęp do wysyłki SMS
    mms Dostęp do wysyłki MMS
    vms Dostęp do wysyłki VMS
    sms_sender Dostęp do zarządzania polami nadawcy SMS
    hlr Dostęp do odwołań HLR
    contacts Dostęp do bazy kontaktów
    subuser Dostęp do zarządzania użytkownikami
    blacklist Dostęp do zarządzania czarną listą
    mfa Dostęp do MFA
    callback Dostęp do zarządzania callbackami
    short_url Dostęp do zarządzania skróconymi linkami
    profile Dostęp do zarządzania profilem użytkownika

    W drugim kroku należy przesłać client_secret, code oraz parametry z pierwszego kroku za pomocą metody POST, aby zakończyć proces autoryzacji. Otrzymany access_token można wykorzystać do autoryzacji zapytań do SMSAPI.

    Przykład drugiego kroku:

    curl -X POST "https://api.smsapi.pl/oauth/token" -d "client_id=1112223334444\
    &client_secret=111222333444&code=11112222&grant_type=authorization_code\
    &redirect_uri=https://www.sample.pl/"
    

    Przykładowa odpowiedź:

    {
        "access_token":"A1b***x2Z",
        "token_type":"Bearer",
        "expires":1577836800,
        "expires_in":604800,
        "refresh_token":"c3D*************************4eF"
    }
    
      * access_token  token pozwalający na dostep do zasobów za pośrednictwem API
      * token_type  typ tokena (w przypadku SMSAPI zawsze "Bearer")
      * expires  data wygaśnięcia tokena w formacie unixstamp
      * expires_in  czas ważności tokena (dni, godziny i minuty)
      * refresh_token  refresh token, który pozwala na przedłużenie ważności autoryzacji
    

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    client_secret Prywatna wartość unikalna dla Twojej aplikacji
    code Kod autoryzacyjny zwracany po pierwszym zapytaniu
    grant_type Typ autoryzacji, powinien mieć wartość "authorization_code"
    redirect_uri Adres URL na który zostanie skierowana odpowiedź dla autoryzacji

    Aby utrzymać połączenie należy wysłać zapytanie zawierające refresh_token, który jest otrzymywany w drugim odwołaniu. W kolejnych odwołaniach należy zastąpić access_token i refresh_token nowymi, otrzymanymi w tym zapytaniu.

    Przykład odwołania z refresh_token:

    
    curl -X POST "https://api.smsapi.pl/oauth/token" -d "client_id=123456\
    &client_secret=111222333444&refresh_token=AaaaaBbbbbCccccDdddd\
    &grant_type=refresh_token"
    
    

    Przykładowa odpowiedź:

    {
        "access_token":"BD1***p3k",
        "token_type":"Bearer",
        "expires":1577837800,
        "expires_in":604800,
        "refresh_token":"yn3*************************z54"
    }
    

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    client_secret Prywatna wartość unikalna dla Twojej aplikacji
    refresh_token Token otrzymany w drugim kroku
    grant_type Typ autoryzacji, powinien mieć wartość "refresh_token"

    PKCE

    SMSAPI obsługuje też autoryzację z wykorzystaniem PKCE (Proof Key for Code Exchange). Od standardowej autoryzacji OAuth różni się tym, że w celu jej przeprowadzenia należy wygenerować losowy ciąg znaków code_verifier. W pierwszym kroku należy podać przekształconą wersję tego ciągu znaków pod nazwą code_challenge, a w drugim kroku przesłać code_verifier. Parametr client_secret przesyłany w drugim kroku jest opcjonalny.

    Parametr code_challenge powstaje przez zahashowanie code_verifier metodą SHA256 i zakodowanie hasha za pomocą Base64. Możesz wykonać kodowanie URL Base64, biorąc ciąg zakodowany w Base64 i zmieniając '+' i '/' odpowiednio na '-' i '_', a następnie przycinając końcowe '='.

    Przykład pierwszego kroku autoryzacji (użytkownik jest przekierowywany do SMSAPI, gdzie musi się zalogować i zatwierdzić integrację):

    https://ssl.smsapi.pl/oauth/access?client_id=123456&redirect_uri=https://www.sample.pl/&code_challenge=12345678&code_challenge_method=S256&scope=sms
    

    Przykładowa odpowiedź:

    https://www.sample.pl/?code=11112222
    

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    redirect_uri Adres URL, na który zostanie przekierowany użytkownik po autoryzacji
    code_challenge Parametr generowany jak opisano wyżej
    code_challenge_method Metoda generowania code_challenge, powinna zawsze mieć wartość S256
    scope Zdefiniowane uprawnienia do funkcjonalności
    state Opcjonalny parametr - token CSRF

    Przykład drugiego kroku:

    curl -X POST "https://api.smsapi.pl/oauth/token" -d "client_id=1112223334444\
    &code_verifier=111222333444&code=11112222&grant_type=authorization_code\
    &redirect_uri=https://www.sample.pl/"
    

    Przykładowa odpowiedź:

    {
        "access_token":"A1b***x2Z",
        "token_type":"Bearer",
        "expires":1577836800,
        "expires_in":604800,
        "refresh_token":"c3D*************************4eF"
    } 
    
      * access_token  token pozwalający na dostep do zasobów za pośrednictwem API
      * token_type  typ tokena (w przypadku SMSAPI zawsze "Bearer")
      * expires  data wygaśnięcia tokena w formacie unixstamp
      * expires_in  czas ważności tokena (dni, godziny i minuty)
      * refresh_token  refresh token, który pozwala na przedłużenie ważności autoryzacji
    

    Po otrzymaniu pozytywnej weryfikacji w pierwszym zapytaniu należy dosłać informacje za pomocą metody POST aby zakończyć proces autoryzacji. Otrzymany access_token można wykorzystać do autoryzacji zapytań do SMSAPI.

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    code Kod autoryzacyjny zwracany po pierwszym zapytaniu
    grant_type Typ autoryzacji, powinien mieć wartość "authorization_code"
    redirect_uri Adres URL, na który zostanie przekierowany użytkownik po autoryzacji
    client_secret Opcjonalny parametr - prywatna wartość unikalna dla Twojej aplikacji

    Aby utrzymać połączenie należy wysłać zapytanie zawierające refresh_token, który jest otrzymywany w drugim odwołaniu. W kolejnych odwołaniach należy zastąpić access_token i refresh_token nowymi, otrzymanymi w tym zapytaniu.

    Przykład odwołania z refresh_token:

    
    curl -X POST "https://api.smsapi.pl/oauth/token" -H "client_id=123456\
    &refresh_token=AaaaaBbbbbCccccDdddd&grant_type=refresh_token"
    
    

    Przykładowa odpowiedź:

    {
        "access_token":"BD1*p3k",
        "token_type":"Bearer",
        "expires":1577837800,
        "expires_in":604800,
        "refresh_token":"yn3***********************z54"
    }
    

    Wymagane parametry:

    Parametr Opis
    client_id Unikalne ID dla aplikacji
    refresh_token Token otrzymany w drugim kroku
    grant_type Typ autoryzacji, powinien mieć wartość "refresh_token"

    Pozostałe Integracje

    Pozostałe serwisy i usługi, które można zintegrować z SMSAPI znajdziesz tutaj: Integracje.