Base URL https://anindasms.com/api/v1
REST · JSON · v1

Automate SMS verification with our API

REST JSON API covering 200+ countries and 5000+ popular services. Allocate virtual numbers and verify SMS codes with a few lines of code.

In seconds200+ countries and 5000+ services supported; instant number allocation with automated OTP polling.
Secure keysHeader-only auth, hashed storage, rate limits and optional IP allowlist.
JSON responsesModern REST. Easy with Curl, Node, Python or any language.
Balance checksQuery balance and prices before ordering; clear errors on low funds.
Live example
Request · cURL
curl -X POST "https://anindasms.com/api/v1/order" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"service":"wa","country":"62"}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/order');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['service' => 'wa', 'country' => '62']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/order",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"service": "wa", "country": "62"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/order", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ service: "wa", country: "62" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"service\":\"wa\",\"country\":\"62\"}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/order", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"service":"wa","country":"62"}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/order", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 58231,
        "phone": "+905551234567",
        "status": "waiting"
    }
}

Authentication

Send your API key in an HTTP header with every request. You can use either method:

HeaderValue
AuthorizationBearer YOUR_API_KEY
X-API-KeyYOUR_API_KEY
For security, never send the key in the URL (?api_key=) or the request body; such requests are rejected with 401. You can define an IP allowlist on your profile page and regenerate the key with one click if it leaks.
HTTP
GET /api/v1/balance HTTP/1.1
Host: anindasms.com
Authorization: Bearer YOUR_API_KEY
401 Unauthorized
{
    "success": false,
    "error": "Geçersiz API key."
}

Response format

All responses are JSON and share the same envelope. Successful requests return success: true with the result inside data; errors return success: false with a message in error. The HTTP status code reflects the outcome as well.

FieldTypeDescription
successbooleanWhether the request succeeded
dataobjectResult data (may hold extra details on errors)
errorstringError message (errors only)
Success
{
    "success": true,
    "data": {
        "balance": 152.4,
        "currency": "TRY",
        "formatted": "₺152,40"
    }
}
402 · Error
{
    "success": false,
    "error": "Yetersiz bakiye.",
    "data": {
        "balance": 12.5,
        "required": 38.82
    }
}

Rate limits

Requests are limited per minute for fair use. When exceeded, 429 is returned; wait for the number of seconds in the Retry-After header and retry.

ScopeLimit
All requests120 / minute
POST /order30 / minute

Response headers

X-RateLimit-LimitTotal allowance per minute
X-RateLimit-RemainingRemaining requests
X-RateLimit-ResetWhen the counter resets (unix time)
HTTP
HTTP/1.1 429 Too Many Requests
Retry-After: 18
X-RateLimit-Limit: 30
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1792850400
Account

Account summary

GET /api/v1/me

Returns a summary of the account linked to your API key. Ideal for checking that your key works when testing an integration for the first time.

Response fields (data)

FieldTypeDescription
idintegerUser ID
usernamestringUsername
emailstringE-mail address
balancenumberCurrent balance
currencystringCurrency (always TRY)
api_key_prefixstringFirst characters of the key (for identification)
api_key_created_atdatetimeKey creation time
api_key_last_used_atdatetime|nullLast time the key was used
Request · cURL
curl "https://anindasms.com/api/v1/me" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/me');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/me",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/me", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/me");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/me", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "id": 1024,
        "username": "demo",
        "email": "[email protected]",
        "balance": 152.4,
        "currency": "TRY",
        "api_key_prefix": "a1b2c3d4",
        "api_key_created_at": "2026-10-01 12:00:00",
        "api_key_last_used_at": "2026-10-24 14:05:11"
    }
}
Account

Current balance

GET /api/v1/balance

Returns your current account balance. Check it before ordering to avoid insufficient-balance errors.

Response fields (data)

FieldTypeDescription
balancenumberCurrent balance
currencystringCurrency (TRY)
formattedstringDisplay-ready balance
Request · cURL
curl "https://anindasms.com/api/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/balance');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/balance",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/balance", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/balance");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/balance", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "balance": 152.4,
        "currency": "TRY",
        "formatted": "₺152,40"
    }
}
SMS Verification API

Active service list

GET /api/v1/services

Lists every service you can currently get a number for. Use the returned code as the service parameter when querying prices and placing orders.

Response fields (data)

FieldTypeDescription
services[].codestringService code (e.g. wa = WhatsApp)
services[].namestringService name
Request · cURL
curl "https://anindasms.com/api/v1/services" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/services');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/services",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/services", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/services");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/services", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "services": [
            {
                "code": "wa",
                "name": "WhatsApp"
            },
            {
                "code": "tg",
                "name": "Telegram"
            },
            {
                "code": "go",
                "name": "Google / Gmail"
            }
        ]
    }
}
SMS Verification API

Country prices / stock

GET /api/v1/prices

Returns per-country price and stock for a service. If you send country, only that country's price is returned.

Parameters

FieldTypeDescription
service string required Service code (from /services)
country string optional Country ID. When sent, a single-country price is returned.

Response fields (data)

FieldTypeDescription
prices[].countrystringCountry ID (used when ordering)
prices[].namestringCountry name
prices[].pricenumberYour price (TRY)
prices[].stockintegerAvailable number stock
prices[].availablebooleanWhether it can be ordered right now
Request · cURL
curl "https://anindasms.com/api/v1/prices?service=wa" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/prices?service=wa');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/prices?service=wa",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/prices?service=wa", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/prices?service=wa");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/prices?service=wa", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "service": "wa",
        "prices": [
            {
                "country": "62",
                "name": "Turkey",
                "price": 38.82,
                "formatted": "₺38,82",
                "stock": 412,
                "available": true
            },
            {
                "country": "16",
                "name": "United Kingdom",
                "price": 24.5,
                "formatted": "₺24,50",
                "stock": 1280,
                "available": true
            }
        ]
    }
}
SMS Verification API

Create a number order

POST /api/v1/order

Buys a number for the selected service and country. The fee is deducted from your balance and the number is returned instantly. Then poll the order status to receive the SMS code.

Body parameters (JSON)

FieldTypeDescription
service string required Service code
country string required Country ID
operator string optional Operator (default: any). Ignored where not supported.

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID — required for status, cancel and complete
phonestringPurchased phone number
costnumberCharged amount (TRY)
balancenumberBalance after the order
statusstringInitial status: waiting
expires_atdatetimeNumber expiry (10 min)
If your balance is insufficient, 402 is returned with balance and required inside data. If there is no stock, 409 is returned.
Request · cURL
curl -X POST "https://anindasms.com/api/v1/order" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"service":"wa","country":"62"}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/order');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['service' => 'wa', 'country' => '62']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/order",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"service": "wa", "country": "62"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/order", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ service: "wa", country: "62" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"service\":\"wa\",\"country\":\"62\"}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/order", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"service":"wa","country":"62"}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/order", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 58231,
        "phone": "+905551234567",
        "service": "wa",
        "country": "62",
        "operator": null,
        "cost": 38.82,
        "balance": 113.58,
        "status": "waiting",
        "expires_at": "2026-10-24 14:12:10"
    }
}
SMS Verification API

Order status + OTP

GET /api/v1/order/{id}

Returns the current status of the order. When the SMS arrives, status becomes received and the code is in the code field. Polling every 3–5 seconds until the code arrives is enough.

Parameters

FieldTypeDescription
id integer required Order ID (in the URL)

Response fields (data)

FieldTypeDescription
statusstringwaiting · received · done · cancelled · expired
codestring|nullVerification code (when received)
sms_textstring|nullFull SMS text
remainingintegerRemaining waiting time (seconds)
expires_atdatetimeNumber expiry
Request · cURL
curl "https://anindasms.com/api/v1/order/58231" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/order/58231');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/order/58231",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/order/58231", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/order/58231");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/order/58231", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 58231,
        "phone": "+905551234567",
        "service": "wa",
        "country": "62",
        "status": "received",
        "cost": 38.82,
        "code": "482913",
        "sms_text": "Your WhatsApp code: 482-913",
        "remaining": 0,
        "created_at": "2026-10-24 14:02:10",
        "expires_at": "2026-10-24 14:12:10"
    }
}
SMS Verification API

Cancel and refund

POST /api/v1/order/{id}/cancel

Cancels an order that has not received an SMS and refunds the fee to your balance. Orders cannot be cancelled after the SMS arrives.

Parameters

FieldTypeDescription
id integer required Order ID (in the URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
statusstringcancelled
balancenumberBalance after the refund
For some numbers, cancellation becomes available shortly after ordering. In that case 400 is returned with data.wait_left (seconds).
Request · cURL
curl -X POST "https://anindasms.com/api/v1/order/58231/cancel" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/order/58231/cancel');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/order/58231/cancel",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/order/58231/cancel", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.PostAsync("https://anindasms.com/api/v1/order/58231/cancel", null);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/order/58231/cancel", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 58231,
        "status": "cancelled",
        "balance": 152.4
    }
}
SMS Verification API

Mark order done

POST /api/v1/order/{id}/done

Marks the order as completed after you have received the code. Works on waiting or received orders.

Parameters

FieldTypeDescription
id integer required Order ID (in the URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
statusstringdone
Request · cURL
curl -X POST "https://anindasms.com/api/v1/order/58231/done" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/order/58231/done');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/order/58231/done",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/order/58231/done", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.PostAsync("https://anindasms.com/api/v1/order/58231/done", null);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/order/58231/done", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 58231,
        "status": "done"
    }
}
Proxy API

Proxy Types

GET /api/v1/proxy/types

Lists all available proxy types (datacenter, residential, ipv6, mobile) and their features.

Response fields (data)

FieldTypeDescription
types[].typestringProxy type key (datacenter, residential, ipv6, mobile)
types[].namestringDisplay name
types[].protocolstringProtocol (HTTP / SOCKS5)
types[].descriptionstringDescription
Request · cURL
curl "https://anindasms.com/api/v1/proxy/types" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/types');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/proxy/types",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/types", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/proxy/types");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/proxy/types", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "types": [
            {
                "type": "datacenter",
                "name": "Statik Veri Merkezi",
                "protocol": "HTTP/SOCKS5",
                "description": "Yüksek hızlı, kesintisiz sunucu IP'leri."
            },
            {
                "type": "residential",
                "name": "Konut (Residential)",
                "protocol": "HTTP/SOCKS5",
                "description": "Gerçek ev interneti IP'leri, bloklanma riski en düşük."
            },
            {
                "type": "ipv6",
                "name": "IPv6 Proxy",
                "protocol": "HTTP/SOCKS5",
                "description": "Ekonomik ve modern IPv6 havuzu."
            },
            {
                "type": "mobile",
                "name": "Mobil 4G/5G",
                "protocol": "HTTP/SOCKS5",
                "description": "Gerçek mobil operatör IP havuzu, rotasyonlu."
            }
        ]
    }
}
Proxy API

Proxy Countries

GET /api/v1/proxy/countries

Lists available countries for the specified proxy type.

Parameters

FieldTypeDescription
type string optional Proxy type. If empty, all supported countries are returned.

Response fields (data)

FieldTypeDescription
countries[].codestring2-letter ISO country code
countries[].namestringCountry name
Request · cURL
curl "https://anindasms.com/api/v1/proxy/countries?type=datacenter" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/countries?type=datacenter');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/proxy/countries?type=datacenter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/countries?type=datacenter", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/proxy/countries?type=datacenter");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/proxy/countries?type=datacenter", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "countries": [
            {
                "code": "TR",
                "name": "Türkiye"
            },
            {
                "code": "US",
                "name": "United States"
            },
            {
                "code": "DE",
                "name": "Germany"
            },
            {
                "code": "GB",
                "name": "United Kingdom"
            }
        ]
    }
}
Proxy API

Proxy Price Calculation

GET /api/v1/proxy/price

Calculates the proxy cost before purchase.

Parameters

FieldTypeDescription
type string required Proxy type
country string optional Country code (optional)
period integer optional Duration in days (default: 30)
quantity integer optional Quantity (default: 1)

Response fields (data)

FieldTypeDescription
unit_pricenumberUnit price (TRY)
total_pricenumberTotal price (TRY)
currencystringCurrency (TRY)
Request · cURL
curl "https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/proxy/price?type=datacenter&country=TR&period=30&quantity=1", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "unit_price": 45,
        "total_price": 45,
        "currency": "TRY"
    }
}
Proxy API

Buy Proxy

POST /api/v1/proxy/buy

Purchases a proxy, deducts the amount from your balance, and immediately delivers IP/port/username/password credentials.

Body parameters (JSON)

FieldTypeDescription
type string required Proxy type
country string required Country code (e.g. TR, US)
period integer optional Duration in days (default: 30)
quantity integer optional Quantity (default: 1)
rotation_interval integer optional Rotation interval in minutes for mobile/rotating proxies

Response fields (data)

FieldTypeDescription
order_idintegerProxy order ID
proxy_typestringProxy type
ipstringProxy host / IP address
portintegerPort number
usernamestringAuth username
passwordstringAuth password
expires_atdatetimeExpiration datetime
Request · cURL
curl -X POST "https://anindasms.com/api/v1/proxy/buy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"type":"datacenter","country":"TR","period":30,"quantity":1}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/buy');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['type' => 'datacenter', 'country' => 'TR', 'period' => '30', 'quantity' => '1']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/proxy/buy",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"type": "datacenter", "country": "TR", "period": "30", "quantity": "1"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/buy", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ type: "datacenter", country: "TR", period: "30", quantity: "1" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"type\":\"datacenter\",\"country\":\"TR\",\"period\":30,\"quantity\":1}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/proxy/buy", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"type":"datacenter","country":"TR","period":30,"quantity":1}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/proxy/buy", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 1042,
        "proxy_type": "datacenter",
        "ip": "185.193.124.50",
        "port": 8080,
        "username": "user_1042",
        "password": "sec_984f2b",
        "expires_at": "2026-11-24 14:00:00"
    }
}
Proxy API

Proxy Orders

GET /api/v1/proxy/orders

Lists all your proxy orders.

Parameters

FieldTypeDescription
page integer optional Page number (default: 1)
limit integer optional Page limit (default: 20)

Response fields (data)

FieldTypeDescription
orders[].order_idintegerOrder ID
orders[].proxy_typestringType
orders[].ipstringHost / IP
orders[].statusstringStatus (active, expired)
orders[].expires_atdatetimeExpiration date
Request · cURL
curl "https://anindasms.com/api/v1/proxy/orders" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/orders');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/proxy/orders",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/orders", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/proxy/orders");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/proxy/orders", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "orders": [
            {
                "order_id": 1042,
                "proxy_type": "datacenter",
                "ip": "185.193.124.50",
                "status": "active",
                "expires_at": "2026-11-24 14:00:00"
            }
        ]
    }
}
Proxy API

Proxy Order Detail

GET /api/v1/proxy/orders/{id}

Fetches credentials and connection details of a proxy order.

Parameters

FieldTypeDescription
id integer required Proxy order ID (in URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
proxy_typestringProxy type
ipstringIP
portintegerPort
usernamestringUsername
passwordstringPassword
statusstringStatus
expires_atdatetimeExpiration
Request · cURL
curl "https://anindasms.com/api/v1/proxy/orders/1042" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/proxy/orders/1042');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/proxy/orders/1042",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/proxy/orders/1042", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/proxy/orders/1042");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/proxy/orders/1042", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 1042,
        "proxy_type": "datacenter",
        "ip": "185.193.124.50",
        "port": 8080,
        "username": "user_1042",
        "password": "sec_984f2b",
        "status": "active",
        "expires_at": "2026-11-24 14:00:00"
    }
}
eSIM API

eSIM Countries

GET /api/v1/esim/countries

Lists countries where eSIM data packages are available.

Response fields (data)

FieldTypeDescription
countries[].codestring2-letter ISO country code
countries[].namestringCountry name
Request · cURL
curl "https://anindasms.com/api/v1/esim/countries" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/countries');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/esim/countries",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/countries", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/esim/countries");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/esim/countries", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "countries": [
            {
                "code": "TR",
                "name": "Turkey"
            },
            {
                "code": "US",
                "name": "United States"
            },
            {
                "code": "DE",
                "name": "Germany"
            },
            {
                "code": "FR",
                "name": "France"
            }
        ]
    }
}
eSIM API

eSIM Packages

GET /api/v1/esim/packages

Lists available data packages (GB, validity and price) for a country.

Parameters

FieldTypeDescription
country string optional Country code (e.g. TR). If empty, popular packages are returned.

Response fields (data)

FieldTypeDescription
packages[].package_idstringPackage code / ID (used when purchasing)
packages[].namestringPackage name
packages[].data_mbintegerData quota (MB)
packages[].duration_daysintegerValidity (days)
packages[].pricenumberPrice (TRY)
Request · cURL
curl "https://anindasms.com/api/v1/esim/packages?country=TR" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/packages?country=TR');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/esim/packages?country=TR",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/packages?country=TR", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/esim/packages?country=TR");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/esim/packages?country=TR", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "packages": [
            {
                "package_id": "pkg_tr_1gb_7d",
                "name": "Turkey 1 GB - 7 Gün",
                "data_mb": 1024,
                "duration_days": 7,
                "price": 85
            },
            {
                "package_id": "pkg_tr_3gb_30d",
                "name": "Turkey 3 GB - 30 Gün",
                "data_mb": 3072,
                "duration_days": 30,
                "price": 175
            },
            {
                "package_id": "pkg_tr_5gb_30d",
                "name": "Turkey 5 GB - 30 Gün",
                "data_mb": 5120,
                "duration_days": 30,
                "price": 250
            }
        ]
    }
}
eSIM API

Buy eSIM

POST /api/v1/esim/buy

Purchases the selected eSIM package. Returns the QR code URL and LPA activation string instantly.

Body parameters (JSON)

FieldTypeDescription
package_id string required Package ID or code
quantity integer optional Quantity (default: 1)

Response fields (data)

FieldTypeDescription
order_idintegereSIM order ID
iccidstringeSIM ICCID number
qr_code_urlstringQR code installation image URL
lpa_stringstringLPA string for manual setup
statusstringInitial status (active)
Request · cURL
curl -X POST "https://anindasms.com/api/v1/esim/buy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"package_id":"pkg_tr_1gb_7d"}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/buy');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['package_id' => 'pkg_tr_1gb_7d']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/esim/buy",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"package_id": "pkg_tr_1gb_7d"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/buy", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ package_id: "pkg_tr_1gb_7d" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"package_id\":\"pkg_tr_1gb_7d\"}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/esim/buy", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"package_id":"pkg_tr_1gb_7d"}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/esim/buy", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 329,
        "iccid": "8985231024829102481",
        "qr_code_url": "https://anindasms.com/uploads/esim/qr_329.png",
        "lpa_string": "LPA:1$rsp.example.com$MATCHING_ID_329",
        "status": "active"
    }
}
eSIM API

eSIM Orders

GET /api/v1/esim/orders

Lists all your eSIM orders.

Parameters

FieldTypeDescription
page integer optional Page
limit integer optional Limit

Response fields (data)

FieldTypeDescription
orders[].order_idintegerOrder ID
orders[].iccidstringICCID
orders[].statusstringStatus
Request · cURL
curl "https://anindasms.com/api/v1/esim/orders" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/orders');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/esim/orders",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/orders", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/esim/orders");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/esim/orders", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "orders": [
            {
                "order_id": 329,
                "iccid": "8985231024829102481",
                "status": "active"
            }
        ]
    }
}
eSIM API

eSIM Order Detail

GET /api/v1/esim/orders/{id}

Fetches details, data usage, and installation info of an eSIM order.

Parameters

FieldTypeDescription
id integer required eSIM order ID (in URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
iccidstringICCID
qr_code_urlstringQR code URL
lpa_stringstringLPA string
data_total_mbintegerTotal data (MB)
data_used_mbintegerUsed data (MB)
statusstringStatus
Request · cURL
curl "https://anindasms.com/api/v1/esim/orders/329" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/orders/329');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/esim/orders/329",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/orders/329", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/esim/orders/329");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/esim/orders/329", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 329,
        "iccid": "8985231024829102481",
        "qr_code_url": "https://anindasms.com/uploads/esim/qr_329.png",
        "lpa_string": "LPA:1$rsp.example.com$MATCHING_ID_329",
        "data_total_mb": 1024,
        "data_used_mb": 140,
        "status": "active"
    }
}
eSIM API

eSIM Topup

POST /api/v1/esim/orders/{id}/topup

Adds a topup data package to an existing eSIM order.

Body parameters (JSON)

FieldTypeDescription
id integer required eSIM order ID (in URL)
package_id string required Topup package ID

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
statusstringsuccess
balancenumberBalance after topup
Request · cURL
curl -X POST "https://anindasms.com/api/v1/esim/orders/329/topup" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"package_id":"pkg_tr_1gb_7d"}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/esim/orders/329/topup');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['package_id' => 'pkg_tr_1gb_7d']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/esim/orders/329/topup",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"package_id": "pkg_tr_1gb_7d"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/esim/orders/329/topup", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ package_id: "pkg_tr_1gb_7d" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"package_id\":\"pkg_tr_1gb_7d\"}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/esim/orders/329/topup", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"package_id":"pkg_tr_1gb_7d"}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/esim/orders/329/topup", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 329,
        "status": "success",
        "balance": 115
    }
}
Temporary Mail API

Mail Domains

GET /api/v1/mail/domains

Lists active domains available for temporary email creation.

Response fields (data)

FieldTypeDescription
domains[].domainstringDomain name (e.g. mailtemp.me)
domains[].is_activebooleanWhether active
Request · cURL
curl "https://anindasms.com/api/v1/mail/domains" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/domains');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/mail/domains",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/domains", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/mail/domains");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/mail/domains", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "domains": [
            {
                "domain": "tempmail.com.tr",
                "is_active": true
            },
            {
                "domain": "fastinbox.net",
                "is_active": true
            }
        ]
    }
}
Temporary Mail API

Create Temporary Mailbox

POST /api/v1/mail/create

Creates a temporary email inbox. Incoming messages can be read via API during its lifetime.

Body parameters (JSON)

FieldTypeDescription
duration integer optional Validity in minutes (default: 60)
domain string optional Preferred domain. Auto-selected if empty.
prefix string optional Preferred username prefix. Randomly generated if empty.

Response fields (data)

FieldTypeDescription
order_idintegerMail order ID
emailstringGenerated email address
costnumberCharged amount (TRY)
expires_atdatetimeExpiration datetime
Request · cURL
curl -X POST "https://anindasms.com/api/v1/mail/create" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration":60}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/create');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['duration' => '60']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/mail/create",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"duration": "60"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/create", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ duration: "60" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"duration\":60}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/mail/create", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"duration":60}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/mail/create", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 892,
        "email": "[email protected]",
        "cost": 5,
        "expires_at": "2026-10-24 15:00:00"
    }
}
Temporary Mail API

My Mailboxes

GET /api/v1/mail/orders

Lists your temporary mailbox orders.

Parameters

FieldTypeDescription
page integer optional Page
limit integer optional Limit

Response fields (data)

FieldTypeDescription
orders[].order_idintegerOrder ID
orders[].emailstringEmail
orders[].statusstringStatus (active, expired, cancelled)
orders[].expires_atdatetimeExpiration
Request · cURL
curl "https://anindasms.com/api/v1/mail/orders" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/orders');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/mail/orders",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/orders", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/mail/orders");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/mail/orders", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "orders": [
            {
                "order_id": 892,
                "email": "[email protected]",
                "status": "active",
                "expires_at": "2026-10-24 15:00:00"
            }
        ]
    }
}
Temporary Mail API

Mailbox Detail

GET /api/v1/mail/orders/{id}

Returns status of a temporary mailbox.

Parameters

FieldTypeDescription
id integer required Order ID (URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
emailstringEmail
statusstringStatus
expires_atdatetimeExpiration
Request · cURL
curl "https://anindasms.com/api/v1/mail/orders/892" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/orders/892');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/mail/orders/892",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/orders/892", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/mail/orders/892");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/mail/orders/892", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 892,
        "email": "[email protected]",
        "status": "active",
        "expires_at": "2026-10-24 15:00:00"
    }
}
Temporary Mail API

Read Inbox Messages

GET /api/v1/mail/orders/{id}/messages

Fetches all incoming messages (sender, subject, HTML and plain text bodies) received in the mailbox.

Parameters

FieldTypeDescription
id integer required Order ID (URL)

Response fields (data)

FieldTypeDescription
messages[].idintegerMessage ID
messages[].fromstringSender email
messages[].subjectstringSubject
messages[].body_textstringPlain text body
messages[].body_htmlstringHTML body
messages[].received_atdatetimeReceived datetime
Request · cURL
curl "https://anindasms.com/api/v1/mail/orders/892/messages" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/orders/892/messages');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/mail/orders/892/messages",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/orders/892/messages", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/mail/orders/892/messages");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/mail/orders/892/messages", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "messages": [
            {
                "id": 1,
                "from": "[email protected]",
                "subject": "Hesap Doğrulama Kodunuz: 938214",
                "body_text": "Doğrulama kodunuz: 938214",
                "body_html": "<p>Doğrulama kodunuz: <b>938214</b></p>",
                "received_at": "2026-10-24 14:15:22"
            }
        ]
    }
}
Temporary Mail API

Extend Mailbox

POST /api/v1/mail/orders/{id}/extend

Extends the validity of a temporary mailbox.

Body parameters (JSON)

FieldTypeDescription
id integer required Order ID (URL)
duration integer optional Duration to add in minutes (default: 60)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
expires_atdatetimeNew expiration datetime
balancenumberBalance after operation
Request · cURL
curl -X POST "https://anindasms.com/api/v1/mail/orders/892/extend" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration":60}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/orders/892/extend');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['duration' => '60']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/mail/orders/892/extend",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"duration": "60"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/orders/892/extend", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ duration: "60" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"duration\":60}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/mail/orders/892/extend", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"duration":60}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/mail/orders/892/extend", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 892,
        "expires_at": "2026-10-24 16:00:00",
        "balance": 95
    }
}
Temporary Mail API

Cancel / Delete Mailbox

POST /api/v1/mail/orders/{id}/cancel

Immediately closes and deletes the temporary mailbox.

Parameters

FieldTypeDescription
id integer required Order ID (URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
statusstringcancelled
Request · cURL
curl -X POST "https://anindasms.com/api/v1/mail/orders/892/cancel" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/mail/orders/892/cancel');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/mail/orders/892/cancel",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/mail/orders/892/cancel", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.PostAsync("https://anindasms.com/api/v1/mail/orders/892/cancel", null);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/mail/orders/892/cancel", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 892,
        "status": "cancelled"
    }
}
Number Rental API

Rental Durations

GET /api/v1/rent/durations

Lists supported rental duration options (in hours) available on the platform.

Response fields (data)

FieldTypeDescription
durations[].hoursintegerRental duration (hours)
durations[].labelstringDisplay label (e.g. 24 Hours, 3 Days)
Request · cURL
curl "https://anindasms.com/api/v1/rent/durations" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/durations');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/durations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/durations", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/durations");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/durations", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "durations": [
            {
                "hours": 4,
                "label": "4 Saat"
            },
            {
                "hours": 24,
                "label": "24 Saat (1 Gün)"
            },
            {
                "hours": 72,
                "label": "3 Gün"
            },
            {
                "hours": 168,
                "label": "1 Hafta"
            },
            {
                "hours": 720,
                "label": "1 Ay (30 Gün)"
            }
        ]
    }
}
Number Rental API

Rental Countries

GET /api/v1/rent/countries

Lists countries available for rental under the specified duration.

Parameters

FieldTypeDescription
duration integer optional Duration in hours (default: 24)

Response fields (data)

FieldTypeDescription
countries[].idstringCountry ID
countries[].codestring2-letter ISO country code
countries[].namestringCountry name
Request · cURL
curl "https://anindasms.com/api/v1/rent/countries?duration=24" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/countries?duration=24');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/countries?duration=24",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/countries?duration=24", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/countries?duration=24");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/countries?duration=24", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "duration": 24,
        "countries": [
            {
                "id": "62",
                "code": "62",
                "name": "Turkey"
            },
            {
                "id": "16",
                "code": "16",
                "name": "United Kingdom"
            },
            {
                "id": "187",
                "code": "187",
                "name": "United States"
            }
        ]
    }
}
Number Rental API

Rental Services & Prices

GET /api/v1/rent/services

Returns rentable services, current stock, and TRY prices for the selected country and duration.

Parameters

FieldTypeDescription
country string required Country ID or code (e.g. 62)
duration integer optional Duration in hours (default: 24)

Response fields (data)

FieldTypeDescription
services[].servicestringService code (e.g. wa, tg, full)
services[].namestringService name
services[].stockintegerAvailable stock
services[].pricenumberUser price (TRY)
services[].formattedstringFormatted price
Request · cURL
curl "https://anindasms.com/api/v1/rent/services?country=62&duration=24" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/services?country=62&duration=24');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/services?country=62&duration=24",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/services?country=62&duration=24", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/services?country=62&duration=24");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/services?country=62&duration=24", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "country": "62",
        "duration": 24,
        "services": [
            {
                "service": "wa",
                "name": "WhatsApp",
                "stock": 54,
                "price": 125,
                "formatted": "₺125,00",
                "duration": 24
            },
            {
                "service": "tg",
                "name": "Telegram",
                "stock": 38,
                "price": 110,
                "formatted": "₺110,00",
                "duration": 24
            },
            {
                "service": "full",
                "name": "Tüm Servisler (Full Rent)",
                "stock": 18,
                "price": 240,
                "formatted": "₺240,00",
                "duration": 24
            }
        ]
    }
}
Number Rental API

Rental Price Quote

GET /api/v1/rent/prices

Fetches the live quote and stock for a specific service, country, and duration.

Parameters

FieldTypeDescription
service string required Service code (e.g. wa)
country string required Country code
duration integer optional Duration in hours (default: 24)

Response fields (data)

FieldTypeDescription
servicestringService code
countrystringCountry code
durationintegerDuration hours
pricenumberUser price (TRY)
formattedstringFormatted price
stockintegerAvailable stock
Request · cURL
curl "https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/prices?service=wa&country=62&duration=24", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "service": "wa",
        "country": "62",
        "duration": 24,
        "price": 125,
        "formatted": "₺125,00",
        "stock": 54
    }
}
Number Rental API

Rent Number

POST /api/v1/rent/buy

Rents a number for the selected service, country, and duration. Deducts balance and delivers the phone number instantly. You can receive unlimited SMS messages during the rental window.

Body parameters (JSON)

FieldTypeDescription
service string required Service code (e.g. wa or full)
country string required Country ID (e.g. 62)
duration integer optional Duration in hours (default: 24)

Response fields (data)

FieldTypeDescription
order_idintegerRental order ID
phonestringRented phone number
servicestringService
countrystringCountry
durationintegerDuration in hours
costnumberCharged amount (TRY)
balancenumberBalance after order
statusstringStatus: waiting
expires_atdatetimeRental expiration datetime
Request · cURL
curl -X POST "https://anindasms.com/api/v1/rent/buy" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"service":"wa","country":"62","duration":24}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/buy');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['service' => 'wa', 'country' => '62', 'duration' => '24']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/rent/buy",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"service": "wa", "country": "62", "duration": "24"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/buy", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ service: "wa", country: "62", duration: "24" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"service\":\"wa\",\"country\":\"62\",\"duration\":24}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/rent/buy", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"service":"wa","country":"62","duration":24}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/rent/buy", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
201 Created
{
    "success": true,
    "data": {
        "order_id": 74102,
        "phone": "+905559876543",
        "service": "wa",
        "country": "62",
        "duration": 24,
        "cost": 125,
        "balance": 250,
        "status": "waiting",
        "expires_at": "2026-10-25 14:00:00"
    }
}
Number Rental API

My Rental Orders

GET /api/v1/rent/orders

Lists all active and concluded rental orders in your account.

Response fields (data)

FieldTypeDescription
orders[].order_idintegerOrder ID
orders[].phonestringPhone number
orders[].servicestringService
orders[].countrystringCountry
orders[].statusstringStatus (waiting, received, done, expired, cancelled)
orders[].costnumberCost (TRY)
orders[].rent_time_hoursintegerRental hours
orders[].sms_countintegerReceived SMS count
orders[].expires_atdatetimeExpiration datetime
Request · cURL
curl "https://anindasms.com/api/v1/rent/orders" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/orders');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/orders",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/orders", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/orders");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/orders", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "orders": [
            {
                "order_id": 74102,
                "phone": "+905559876543",
                "service": "wa",
                "country": "62",
                "status": "waiting",
                "cost": 125,
                "rent_time_hours": 24,
                "sms_count": 1,
                "created_at": "2026-10-24 14:00:00",
                "expires_at": "2026-10-25 14:00:00"
            }
        ]
    }
}
Number Rental API

Rental Order & SMS Log

GET /api/v1/rent/orders/{id}

Fetches the rental status, remaining time, and all SMS verification codes and texts received during the rental window.

Parameters

FieldTypeDescription
id integer required Rental order ID (URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
phonestringPhone
statusstringwaiting · received · done · expired · cancelled
remainingintegerRemaining seconds
can_cancelbooleanCan cancel (first 20 min if no SMS)
sms_listarrayAll received SMS messages
sms_list[].codestringVerification code
sms_list[].textstringFull SMS text
sms_list[].datestringReceived time
Request · cURL
curl "https://anindasms.com/api/v1/rent/orders/74102" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/orders/74102');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.get(
    "https://anindasms.com/api/v1/rent/orders/74102",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/orders/74102", {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.GetAsync("https://anindasms.com/api/v1/rent/orders/74102");
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://anindasms.com/api/v1/rent/orders/74102", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 74102,
        "phone": "+905559876543",
        "service": "wa",
        "country": "62",
        "status": "received",
        "remaining": 82400,
        "can_cancel": false,
        "expires_at": "2026-10-25 14:00:00",
        "sms_list": [
            {
                "code": "948210",
                "text": "WhatsApp verification code: 948-210",
                "date": "2026-10-24 14:12:00"
            }
        ]
    }
}
Number Rental API

Cancel Rental Order

POST /api/v1/rent/orders/{id}/cancel

Cancels the rental order within the 20-minute window if no SMS was received, with full refund.

Parameters

FieldTypeDescription
id integer required Rental order ID (URL)

Response fields (data)

FieldTypeDescription
order_idintegerOrder ID
statusstringcancelled
balancenumberBalance after refund
Request · cURL
curl -X POST "https://anindasms.com/api/v1/rent/orders/74102/cancel" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/orders/74102/cancel');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
    ],
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/rent/orders/74102/cancel",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/orders/74102/cancel", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
  },
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var res = await client.PostAsync("https://anindasms.com/api/v1/rent/orders/74102/cancel", null);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/rent/orders/74102/cancel", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 74102,
        "status": "cancelled",
        "balance": 375
    }
}
Number Rental API

Reactivate / Extend Rental

POST /api/v1/rent/orders/{id}/reactivate

Reactivates or extends the same phone number for an additional duration.

Body parameters (JSON)

FieldTypeDescription
id integer required Previous rental order ID (URL)
duration integer optional Duration in hours (default: 24)

Response fields (data)

FieldTypeDescription
order_idintegerNew order ID
phonestringSame phone number
durationintegerDuration in hours
costnumberCharged amount (TRY)
expires_atdatetimeNew expiration datetime
Request · cURL
curl -X POST "https://anindasms.com/api/v1/rent/orders/74102/reactivate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration":24}'
<?php
$ch = curl_init('https://anindasms.com/api/v1/rent/orders/74102/reactivate');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode(['duration' => '24']),
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($response);
import requests

response = requests.post(
    "https://anindasms.com/api/v1/rent/orders/74102/reactivate",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"duration": "24"},
)
print(response.json())
const res = await fetch("https://anindasms.com/api/v1/rent/orders/74102/reactivate", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ duration: "24" }),
});

console.log(await res.json());
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var body = new StringContent("{\"duration\":24}", Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://anindasms.com/api/v1/rent/orders/74102/reactivate", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());
package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{"duration":24}`)
	req, _ := http.NewRequest("POST", "https://anindasms.com/api/v1/rent/orders/74102/reactivate", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}
200 OK
{
    "success": true,
    "data": {
        "order_id": 74215,
        "phone": "+905559876543",
        "duration": 24,
        "cost": 125,
        "balance": 250,
        "status": "waiting",
        "expires_at": "2026-10-26 14:00:00"
    }
}

Order statuses

The status field in the GET /order/{id} response takes one of the following values.

statusDescription
waitingNumber purchased, waiting for the SMS.
receivedSMS received, the code is in the code field.
doneOrder completed.
cancelledCancelled, the fee was refunded.
expiredNo SMS within 10 minutes, the fee was refunded automatically.
Flow
waiting ──► received ──► done
   │
   ├──► cancelled   (cancel + refund)
   └──► expired     (10 min · auto refund)

Error codes

Failed requests return an appropriate HTTP status code and a descriptive error message.

HTTPDescription
400Missing / invalid parameter or action not allowed in this state
401API key missing or invalid
402Insufficient balance
403Account suspended, e-mail not verified, IP not allowed or service disabled
404Order or service/country not found
409Out of stock
413Request body too large
429Rate limit exceeded — wait for the Retry-After header
500 / 502Temporary server or provider error — retry
409 Conflict
{
    "success": false,
    "error": "Bu ülke/servis için stok bulunmuyor."
}
429 Too Many Requests
{
    "success": false,
    "error": "Rate limit aşıldı. Dakikada en fazla 30 istek."
}

Official SDKs

Use our open-source SDKs to speed up your integration. They all share the same methods, turn errors into clear exceptions and include a waitForCode helper that waits for the SMS code for you.

GitHub

Shared methods

me() · balance()Account and balance
services() · prices(service, country?)Services, prices and stock
createOrder(service, country, operator?)Create a number order
getOrder(id)Order status + OTP
cancelOrder(id) · completeOrder(id)Cancel and refund · Mark order done
waitForCode(id)Waits until the code arrives and returns it
Install · cURL
# No SDK needed for cURL — use the request examples above.
composer config repositories.anindasms vcs https://github.com/anindasms-dev/anindasms-sdk
composer require anindasms/sdk:dev-main
pip install "git+https://github.com/anindasms-dev/anindasms-sdk.git#subdirectory=python"
npm install github:anindasms-dev/anindasms-sdk
# Add csharp/AnindaSms.cs to your project (.NET 6+)
go get github.com/anindasms-dev/anindasms-sdk/go
Usage · cURL
curl "https://anindasms.com/api/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY"
<?php
require 'vendor/autoload.php';

$client = new AnindaSms\Client('YOUR_API_KEY');

$order = $client->createOrder('wa', '62');
echo $order['phone'];

$sms = $client->waitForCode($order['order_id']);
echo $sms['code'];
from anindasms import Client

client = Client("YOUR_API_KEY")

order = client.create_order("wa", "62")
print(order["phone"])

sms = client.wait_for_code(order["order_id"])
print(sms["code"])
const { AnindaSMS } = require("anindasms");

const client = new AnindaSMS("YOUR_API_KEY");

const order = await client.createOrder("wa", "62");
console.log(order.phone);

const sms = await client.waitForCode(order.order_id);
console.log(sms.code);
using AnindaSms;

var client = new AnindaSmsClient("YOUR_API_KEY");

var order = await client.CreateOrderAsync("wa", "62");
Console.WriteLine(order.GetProperty("phone").GetString());

var sms = await client.WaitForCodeAsync(order.GetProperty("order_id").GetInt32());
Console.WriteLine(sms.GetProperty("code").GetString());
package main

import (
	"fmt"

	anindasms "github.com/anindasms-dev/anindasms-sdk/go"
)

func main() {
	client := anindasms.NewClient("YOUR_API_KEY")

	order, err := client.CreateOrder("wa", "62", "")
	if err != nil {
		panic(err)
	}
	fmt.Println(order.Phone)

	sms, err := client.WaitForCode(order.OrderID, 0, 0)
	if err != nil {
		panic(err)
	}
	fmt.Println(*sms.Code)
}

API FAQ

Common integration questions.

Where do I get an API key?

After signing up, create a key on the Profile page. The full key is shown only once when generated.

Which languages are supported?

Any language works with REST JSON: PHP, Python, Node.js, Go, C#… Curl samples are in the docs.

What if SMS never arrives?

Same as the panel: refunds apply on expiry or successful cancel. Status returns expired / cancelled.

Is there a rate limit?

Yes: 120 requests/min overall, 30 orders/min. Over limit returns HTTP 429 with X-RateLimit headers. Poll status every 2–5s.

How is the key protected?

Keys are stored hashed and accepted only via headers. You can set an IP allowlist on Profile and rotate if leaked.

Ready to integrate?
Sign up, create an API key, and get your first number in a few lines. Contact →
Integrate now

Get your key and place your first API order.

Sign up free & get a key