SMS

SMS sending, OTP and verification, and delivery status.

1. Overview

Base path: https://api.infrai.cc/v1/sms

Auth header: Authorization: Bearer $INFRAI_API_KEY

bash

# Call any /v1/sms capability over raw HTTP — no SDK to install.
# curl:
curl https://api.infrai.cc/v1/sms/... \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json"

2. Methods (21)

2.1sms.send

POST /v1/sms/send

Send an SMS message; supports templates.

Parameters

Name	Type	Required	Description
`to`	`string`	Required	Recipient phone number in E.164.
`body`	`string`	Optional	Message text.
`from`	`string`	Optional	Sender id or number.
`template_id`	`string`	Optional	Template id to render instead of a body.
`vendor`	`string`	Optional	Pin a specific vendor instead of auto-routing.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

SmsRecord { sms_id, to, state, vendor, segments, created_at }

Name	Type	Description
`message_id`	`string`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource
`vendor`	`string`	Vendor that handled or will handle this request
`segments`	`integer`	Long SMS multi-part billing count. `≥ 1`
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/send \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+14155550100", "body": "Your code is 123456"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/send",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': '+14155550100', 'body': 'Your code is 123456'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+14155550100", "body": "Your code is 123456"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+14155550100", "body": "Your code is 123456"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"to": "+14155550100", "body": "Your code is 123456"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/send", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/send"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"to\": \"+14155550100\", \"body\": \"Your code is 123456\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/send");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"to\": \"+14155550100\", \"body\": \"Your code is 123456\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/send");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"to\": \"+14155550100\", \"body\": \"Your code is 123456\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/send")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"to": "+14155550100", "body": "Your code is 123456"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/send")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"to": "+14155550100", "body": "Your code is 123456"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.2sms.otp

POST /v1/sms/otp

Send a one-time passcode to a phone number.

Parameters

Name	Type	Required	Description
`to`	`string`	Required	Recipient phone number in E.164. `e.g. +15555550100`

Returns

{ request_id, expires_at }

Name	Type	Description
`message_id`	`string`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource
`vendor`	`string`	Vendor that handled or will handle this request
`segments`	`integer`	Long SMS multi-part billing count. `≥ 1`
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/otp \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+15555550100"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/otp",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': '+15555550100'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/otp",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+15555550100"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/otp",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+15555550100"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"to": "+15555550100"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/otp", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/otp"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"to\": \"+15555550100\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/otp");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"to\": \"+15555550100\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/otp");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"to\": \"+15555550100\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/otp")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"to": "+15555550100"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/otp")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"to": "+15555550100"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.3sms.verify

POST /v1/sms/verify

Verify a one-time passcode.

Parameters

Name	Type	Required	Description
`to`	`string`	Required	Recipient phone number in E.164.
`code`	`string`	Required	The one-time passcode to verify.

Returns

{ valid: boolean }

Name	Type	Description
`verified`	`boolean`	Whether the verification succeeded
`reason`	`"verified" \| "no_code_issued" \| "expired" \| "too_many_attempts" \| "mismatch"`	Outcome reason: 'verified' on success; otherwise why verification failed
`to`	`string`	Phone number that was checked

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/verify \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "sample", "code": "123456"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/verify",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': 'sample', 'code': '123456'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/verify",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample", "code": "123456"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/verify",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample", "code": "123456"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"to": "sample", "code": "123456"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/verify", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/verify"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"to\": \"sample\", \"code\": \"123456\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/verify");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"to\": \"sample\", \"code\": \"123456\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/verify");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"to\": \"sample\", \"code\": \"123456\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/verify")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"to": "sample", "code": "123456"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/verify")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"to": "sample", "code": "123456"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.4sms.status

GET /v1/sms/status/{id}

Fetch the delivery status of an SMS.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	The SMS record id.

Returns

SmsRecord

Name	Type	Description
`id`	`string`	Message id (send returns e.g. 'sms_…'); the archive stores it under 'id'.
`status`	`string`	Lifecycle state: one of enums/SmsState (queued\|sending\|sent\|delivered\|failed\|deferred\|expired\|cancelled\|auto_suppressed) or 'not_found' when the id is unknown.
`channel`	`"sms" \| "email" \| null`	Always 'sms' for this capability.
`account_id`	`string \| null`	Account identifier that owns this resource
`to`	`any`	Recipient(s) as supplied at send time.
`vendor`	`string \| null`	Vendor that handled the send; null on a not-found read.
`vendor_message_id`	`string \| null`	Message identifier assigned by the upstream vendor
`created_at`	`string \| null`	ISO 8601 timestamp when this resource was created `format: date-time`
`found`	`boolean`	true when the id resolved to an archived message; false on a miss. (A miss should raise a typed 404 once SMS_MESSAGE_NOT_FOUND lands — see module notes.)
`state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource
`attempt`	`integer \| null`	Current attempt number (for retries) `≥ 0`
`last_event`	`string \| null`	Description of the most recent event
`delivered_at`	`string \| null`	ISO 8601 timestamp when the message was delivered `format: date-time`
`failed_reason`	`string \| null`	Reason for failure, if the operation failed

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/status/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/status/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/status/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/status/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/status/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/status/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/status/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/status/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.5sms.batch.send

POST /v1/sms/batch/send

Heterogeneous batch sending: Each message is a complete SMS request, the entire batch shares an idempotent key, and billing is not repeated.

Parameters

Name	Type	Required	Description
`messages`	`SmsSendRequest[]`	Required	Array of SMS requests, up to 100 messages, each one is a complete sending request. `1–100 items`
`idempotency_key`	`string`	Optional	Deduplication key shared by the entire batch; same retry returns the same result.

Returns

SmsBatchSendResult { results: SmsSendResult[] }

Name	Type	Description
`results`	`object[]`	List of individual results from a batch operation
`results[].index`	`integer`	Position in the request messages array. `≥ 0`
`results[].result`	`object \| null`	Send result when this item succeeded.
`results[].result.message_id`	`string`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`results[].result.state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource
`results[].result.vendor`	`string`	Vendor that handled or will handle this request
`results[].result.segments`	`integer`	Long SMS multi-part billing count. `≥ 1`
`results[].result.cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`results[].result.created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`results[].error`	`object \| null`	Error when this item failed; result is null.
`results[].error.code`	`string`	Stable identifier from registry.yaml.
`results[].error.http_status`	`integer`	HTTP status code of the webhook delivery attempt `400–599`
`results[].error.message`	`string`	Human-readable hint.
`results[].error.docs_url`	`string`	Documentation URL for this error code `format: uri`
`results[].error.code_detail`	`string`	Sub-classification (e.g. wallet cap reason).
`results[].error.retryable`	`boolean`	Whether the error is retryable
`results[].error.retry_after_ms`	`integer`	Suggested retry delay in milliseconds `≥ 0`
`results[].error.param`	`string`	Which parameter failed validation, if applicable.
`results[].error.trace_id`	`string`	Distributed tracing identifier
`results[].error.request_id`	`string`	Server-assigned request identifier for tracing

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/batch/send \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"to": "sample"}]}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/batch/send",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'messages': [{'to': 'sample'}]},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/batch/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"to": "sample"}]}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/batch/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"to": "sample"}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"messages": [{"to": "sample"}]}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/batch/send", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/batch/send"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"messages\": [{\"to\": \"sample\"}]}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/batch/send");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"messages\": [{\"to\": \"sample\"}]}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/batch/send");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"messages\": [{\"to\": \"sample\"}]}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/batch/send")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"messages": [{"to": "sample"}]}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/batch/send")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"messages": [{"to": "sample"}]}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.6sms.cancel

POST /v1/sms/cancel/{id}

Cancel scheduled or queued text messages that have not yet been sent.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	SMS message ID to cancel.

Returns

SmsCancelResult { message_id, cancelled, state }

Name	Type	Description
`message_id`	`string`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`cancelled`	`boolean`	Whether the resource was successfully cancelled
`state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/cancel/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message_id": "hello"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/cancel/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'message_id': 'hello'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"message_id": "hello"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/cancel/ID", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/cancel/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"message_id\": \"hello\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/cancel/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"message_id\": \"hello\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/cancel/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"message_id\": \"hello\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/cancel/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"message_id": "hello"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/cancel/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"message_id": "hello"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.7sms.events

GET /v1/sms/events/{id}

Read the delivery event timeline of a single text message.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	SMS message ID.
`cursor`	`string`	Optional	Paging cursor, obtained from next_cursor of the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

SmsEventList { items: SmsEvent[], next_cursor }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].type`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed" \| "delivery_receipt" \| "inbound"`	Type discriminator for this resource
`items[].at`	`string`	ISO 8601 timestamp of the event `format: date-time`
`items[].recipient`	`string`	E.164 phone number.
`items[].message_id`	`string \| null`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`items[].meta`	`object \| null`	Additional metadata for the event
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/events/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/events/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/events/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/events/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/events/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/events/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/events/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/events/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/events/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/events/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.8sms.inbound.list

GET /v1/sms/inbound/list

Paginated list of inbound (reply) text messages received on registered sending numbers.

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Paging cursor, obtained from next_cursor of the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

SmsListResult { items, next_cursor }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].type`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed" \| "delivery_receipt" \| "inbound"`	Type discriminator for this resource
`items[].at`	`string`	ISO 8601 timestamp of the event `format: date-time`
`items[].recipient`	`string`	E.164 phone number.
`items[].message_id`	`string \| null`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`items[].meta`	`object \| null`	Additional metadata for the event
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/inbound/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/inbound/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/inbound/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/inbound/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/inbound/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/inbound/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/inbound/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/inbound/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/inbound/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/inbound/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.9sms.resend

POST /v1/sms/resend/{id}

Resend the text message, optionally retrying only failed recipients.

Parameters

Name	Type	Required	Description
`message_id`	`string`	Required	The original SMS message ID to be resent. `pattern: ^sms_[A-Za-z0-9]{20,}$`
`only_failed`	`boolean`	Optional	When true, only failed delivery recipients are retried. `default: true`
`idempotency_key`	`string`	Optional	Deduplication key; same retry returns the same result.

Returns

SmsBatchSendResult { results }

Name	Type	Description
`message_id`	`string`	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`state`	`"queued" \| "sending" \| "sent" \| "delivered" \| "failed" \| "deferred" \| "expired" \| "cancelled" \| "auto_suppressed"`	Current lifecycle state of this resource
`vendor`	`string`	Vendor that handled or will handle this request
`segments`	`integer`	Long SMS multi-part billing count. `≥ 1`
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/resend/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message_id": "hello"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/resend/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'message_id': 'hello'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/resend/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/resend/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"message_id": "hello"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/resend/ID", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/resend/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"message_id\": \"hello\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/resend/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"message_id\": \"hello\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/resend/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"message_id\": \"hello\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/resend/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"message_id": "hello"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/resend/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"message_id": "hello"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.10sms.signature.create

POST /v1/sms/signature/create

Create an SMS signature (required for sending from China) and submit it for review.

Parameters

Name	Type	Required	Description
`name`	`string`	Required	Signature content text.
`type`	`"company" \| "app" \| "website" \| "public_account" \| "store" \| "other"`	Optional	Signature type, such as enterprise, individual. `default: "company"`
`proof_url`	`string`	Optional	URL of qualification document. `format: uri`
`remark`	`string`	Optional	Notes when submitting for review.
`vendor`	`string`	Optional	Pin a specific vendor instead of auto-routing.

Returns

SmsSignature { signature_id, text, type, review_state, reject_reason, vendor, created_at }

Name	Type	Description
`signature_id`	`string`	Unique identifier for this SMS signature
`name`	`string`	Signature text shown as the 【signature】 prefix.
`type`	`"company" \| "app" \| "website" \| "public_account" \| "store" \| "other"`	Signature scene (China vendor signature source). `default: "company"`
`review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	China signatures always start 'pending' review; 'n/a' for non-China. `default: "pending"`
`review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`proof_url`	`string \| null`	URL of the ownership-proof document submitted to the China vendor.
`vendor_sign_id`	`string \| null`	Vendor-assigned sign id (Tencent SignId / Aliyun SignName) remembered after a real submit.
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`found`	`boolean`	Present on sms.signature.get; true when the signature exists. (A missing signature should raise a typed 404 once the SMS_SIGNATURE_NOT_FOUND code lands — see module notes.)

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/signature/create \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Acme", "type": "company"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/signature/create",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'name': 'Acme', 'type': 'company'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "Acme", "type": "company"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "Acme", "type": "company"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"name": "Acme", "type": "company"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/signature/create", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/signature/create"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"name\": \"Acme\", \"type\": \"company\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/signature/create");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"name\": \"Acme\", \"type\": \"company\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/signature/create");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"name\": \"Acme\", \"type\": \"company\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/signature/create")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"name": "Acme", "type": "company"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/signature/create")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"name": "Acme", "type": "company"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.11sms.signature.get

GET /v1/sms/signature/get/{id}

Read a single SMS signature and its review status.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Signature ID.

Returns

SmsSignature

Name	Type	Description
`signature_id`	`string`	Unique identifier for this SMS signature
`name`	`string`	Signature text shown as the 【signature】 prefix.
`type`	`"company" \| "app" \| "website" \| "public_account" \| "store" \| "other"`	Signature scene (China vendor signature source). `default: "company"`
`review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	China signatures always start 'pending' review; 'n/a' for non-China. `default: "pending"`
`review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`proof_url`	`string \| null`	URL of the ownership-proof document submitted to the China vendor.
`vendor_sign_id`	`string \| null`	Vendor-assigned sign id (Tencent SignId / Aliyun SignName) remembered after a real submit.
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`found`	`boolean`	Present on sms.signature.get; true when the signature exists. (A missing signature should raise a typed 404 once the SMS_SIGNATURE_NOT_FOUND code lands — see module notes.)

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/signature/get/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/signature/get/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/signature/get/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/signature/get/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/signature/get/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/signature/get/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/signature/get/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/signature/get/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.12sms.signature.list

GET /v1/sms/signature/list

List SMS signatures in pages.

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Paging cursor, obtained from next_cursor of the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

SmsSignatureListResult { items, next_cursor }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].signature_id`	`string`	Unique identifier for this SMS signature
`items[].name`	`string`	Signature text shown as the 【signature】 prefix.
`items[].type`	`"company" \| "app" \| "website" \| "public_account" \| "store" \| "other"`	Signature scene (China vendor signature source). `default: "company"`
`items[].review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	China signatures always start 'pending' review; 'n/a' for non-China. `default: "pending"`
`items[].review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`items[].proof_url`	`string \| null`	URL of the ownership-proof document submitted to the China vendor.
`items[].vendor_sign_id`	`string \| null`	Vendor-assigned sign id (Tencent SignId / Aliyun SignName) remembered after a real submit.
`items[].created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`items[].updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`items[].found`	`boolean`	Present on sms.signature.get; true when the signature exists. (A missing signature should raise a typed 404 once the SMS_SIGNATURE_NOT_FOUND code lands — see module notes.)
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page
`count`	`integer`	Total number of items across all pages `≥ 0`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/signature/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/signature/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/signature/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/signature/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/signature/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/signature/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/signature/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/signature/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.13sms.signature.delete

DELETE /v1/sms/signature/delete/{id}

Delete an SMS signature.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Signature ID to delete.
`idempotency_key`	`string`	Optional	Deduplication key; same retry returns the same result.

Returns

SmsDeleteResult { deleted }

Name	Type	Description
`signature_id`	`string \| null`	Identifier of the deleted signature
`deleted`	`boolean`	Whether the signature was deleted
`found`	`boolean`	Whether a signature with this id existed

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X DELETE https://api.infrai.cc/v1/sms/signature/delete/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/sms/signature/delete/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/signature/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("DELETE", "https://api.infrai.cc/v1/sms/signature/delete/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/signature/delete/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("DELETE"), "https://api.infrai.cc/v1/sms/signature/delete/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/signature/delete/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/signature/delete/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .delete("https://api.infrai.cc/v1/sms/signature/delete/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.14sms.template.create

POST /v1/sms/template/create

Create reusable SMS templates with named variables.

Parameters

Name	Type	Required	Description
`name`	`string`	Required	Template name.
`body`	`string`	Required	Template text, which can contain {variable} placeholders.
`locale`	`string`	Optional	Template language area, such as en, zh. `default: "en"`
`variables`	`string[]`	Optional	List of variable names used in the template.
`vendor`	`string`	Optional	Pin a specific vendor instead of auto-routing.

Returns

SmsTemplate { template_id, name, body, locale, variables, review_state, created_at }

Name	Type	Description
`template_id`	`string`	Identifier of the template used for rendering
`name`	`string`	Human-readable name for this resource
`body`	`string`	Plain text body of the message
`locale`	`string`	Locale code for the template (e.g. en-US, zh-CN) `default: "en"`
`variables`	`string[]`	Template variable definitions
`review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	Required for China vendors; n/a otherwise. `default: "n/a"`
`review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`vendor_template_id`	`string \| null`	Vendor-assigned template id remembered after a real submit (polled by query_review_state).
`scope`	`"account" \| "platform"`	Template visibility: account-private or platform-shared. `default: "account"`
`vendor`	`string \| null`	SMS vendor that owns the vendor_template_id.
`message_type`	`"otp" \| "notification" \| "marketing" \| null`	Template category requested at creation time. `default: "otp"`
`international`	`0 \| 1 \| null`	Tencent template region flag saved for vendor review polling: 0 mainland China, 1 international/HK/Macau/Taiwan.
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`found`	`boolean`	Present on sms.template.get; true when the template exists. (A missing template should raise a typed 404 once the SMS_TEMPLATE_NOT_FOUND code lands — see module notes.)

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/template/create \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/template/create",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'name': 'otp', 'body': 'Your code is {{code}}', 'locale': 'zh'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/template/create", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/template/create"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"name\": \"otp\", \"body\": \"Your code is {{code}}\", \"locale\": \"zh\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/template/create");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"name\": \"otp\", \"body\": \"Your code is {{code}}\", \"locale\": \"zh\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/template/create");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"name\": \"otp\", \"body\": \"Your code is {{code}}\", \"locale\": \"zh\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/template/create")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/template/create")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"name": "otp", "body": "Your code is {{code}}", "locale": "zh"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.15sms.template.get

GET /v1/sms/template/get/{id}

Read a single SMS template.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Template ID.

Returns

SmsTemplate

Name	Type	Description
`template_id`	`string`	Identifier of the template used for rendering
`name`	`string`	Human-readable name for this resource
`body`	`string`	Plain text body of the message
`locale`	`string`	Locale code for the template (e.g. en-US, zh-CN) `default: "en"`
`variables`	`string[]`	Template variable definitions
`review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	Required for China vendors; n/a otherwise. `default: "n/a"`
`review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`vendor_template_id`	`string \| null`	Vendor-assigned template id remembered after a real submit (polled by query_review_state).
`scope`	`"account" \| "platform"`	Template visibility: account-private or platform-shared. `default: "account"`
`vendor`	`string \| null`	SMS vendor that owns the vendor_template_id.
`message_type`	`"otp" \| "notification" \| "marketing" \| null`	Template category requested at creation time. `default: "otp"`
`international`	`0 \| 1 \| null`	Tencent template region flag saved for vendor review polling: 0 mainland China, 1 international/HK/Macau/Taiwan.
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`found`	`boolean`	Present on sms.template.get; true when the template exists. (A missing template should raise a typed 404 once the SMS_TEMPLATE_NOT_FOUND code lands — see module notes.)

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/template/get/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/template/get/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/template/get/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/template/get/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/template/get/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/template/get/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/template/get/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/template/get/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.16sms.template.list

GET /v1/sms/template/list

List SMS templates in pages.

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Paging cursor, obtained from next_cursor of the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

SmsTemplateListResult { items, next_cursor }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].template_id`	`string`	Identifier of the template used for rendering
`items[].name`	`string`	Human-readable name for this resource
`items[].body`	`string`	Plain text body of the message
`items[].locale`	`string`	Locale code for the template (e.g. en-US, zh-CN) `default: "en"`
`items[].variables`	`string[]`	Template variable definitions
`items[].review_state`	`"pending" \| "approved" \| "rejected" \| "n/a"`	Required for China vendors; n/a otherwise. `default: "n/a"`
`items[].review_reason`	`string \| null`	Vendor reviewer note when review_state=rejected.
`items[].vendor_template_id`	`string \| null`	Vendor-assigned template id remembered after a real submit (polled by query_review_state).
`items[].scope`	`"account" \| "platform"`	Template visibility: account-private or platform-shared. `default: "account"`
`items[].vendor`	`string \| null`	SMS vendor that owns the vendor_template_id.
`items[].message_type`	`"otp" \| "notification" \| "marketing" \| null`	Template category requested at creation time. `default: "otp"`
`items[].international`	`0 \| 1 \| null`	Tencent template region flag saved for vendor review polling: 0 mainland China, 1 international/HK/Macau/Taiwan.
`items[].created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`items[].updated_at`	`string \| null`	ISO 8601 timestamp when this resource was last updated `format: date-time`
`items[].found`	`boolean`	Present on sms.template.get; true when the template exists. (A missing template should raise a typed 404 once the SMS_TEMPLATE_NOT_FOUND code lands — see module notes.)
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page
`count`	`integer`	Total number of items across all pages `≥ 0`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/template/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/template/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/template/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/template/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/template/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/template/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/template/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/template/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.17sms.template.delete

DELETE /v1/sms/template/delete/{id}

Delete an SMS template.

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Template ID to delete.
`idempotency_key`	`string`	Optional	Deduplication key; same retry returns the same result.

Returns

SmsDeleteResult { deleted }

Name	Type	Description
`template_id`	`string \| null`	Identifier of the deleted template
`deleted`	`boolean`	Whether the template was deleted
`found`	`boolean`	Whether a template with this id existed

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X DELETE https://api.infrai.cc/v1/sms/template/delete/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/sms/template/delete/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/template/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("DELETE", "https://api.infrai.cc/v1/sms/template/delete/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/template/delete/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("DELETE"), "https://api.infrai.cc/v1/sms/template/delete/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/template/delete/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/template/delete/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .delete("https://api.infrai.cc/v1/sms/template/delete/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.18sms.suppression.add

POST /v1/sms/suppression/add

Add the number to the suppress (do not disturb) list.

Parameters

Name	Type	Required	Description
`phone`	`string`	Required	Phone number to suppress (E.164 format).
`reason`	`"user_request" \| "stop_reply" \| "carrier_block" \| "invalid" \| "manual"`	Optional	Suppression reasons such as opt_out, complaint. `default: "manual"`
`scope`	`"account"`	Optional	Suppression scope, such as account, global. `default: "account"`
`notes`	`string`	Optional	Internal notes.
`idempotency_key`	`string`	Optional	Deduplication key; same retry returns the same result.

Returns

SuppressionRecord { phone, scope, reason, created_at }

Name	Type	Description
`phone`	`string`	E.164 phone.
`reason`	`"user_request" \| "stop_reply" \| "carrier_block" \| "invalid" \| "manual"`	Reason for the current state or action
`added_at`	`string`	ISO 8601 timestamp when this resource was added `format: date-time`
`scope`	`"account"`	Scope of applicability for this resource
`last_attempt_at`	`string \| null`	ISO 8601 timestamp of the most recent blocked send attempt, if any. `format: date-time`
`attempt_count_blocked`	`integer`	Count of send attempts blocked by this suppression entry so far. `≥ 0`
`notes`	`string \| null`	Free-form notes attached when the entry was added.

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/suppression/add \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "+15555550100"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/suppression/add",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'phone': '+15555550100'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/add",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/add",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"phone": "+15555550100"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/suppression/add", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/suppression/add"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"phone\": \"+15555550100\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/suppression/add");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"phone\": \"+15555550100\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/suppression/add");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"phone\": \"+15555550100\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/suppression/add")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"phone": "+15555550100"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/suppression/add")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"phone": "+15555550100"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.19sms.suppression.check

POST /v1/sms/suppression/check

Check if the number has been suppressed before sending.

Parameters

Name	Type	Required	Description
`phone`	`string`	Required	The phone number to check (E.164 format).
`scope`	`"account"`	Optional	Check the suppression scope, such as account, global. `default: "account"`

Returns

SmsSuppressionCheckResult { suppressed, record }

Name	Type	Description
`phone`	`string`	E.164 phone that was checked.
`suppressed`	`boolean`	Whether the address is currently suppressed
`reason`	`"user_request" \| "stop_reply" \| "carrier_block" \| "invalid" \| "manual"`	Suppression reason; present only when suppressed=true
`added_at`	`string`	ISO 8601 timestamp when the entry was added; present only when suppressed=true `format: date-time`
`scope`	`"account"`	Scope of the matching entry; present only when suppressed=true
`last_attempt_at`	`string \| null`	ISO 8601 timestamp of the most recent blocked send attempt, if any `format: date-time`
`attempt_count_blocked`	`integer`	Count of send attempts blocked by this suppression entry so far; present only when suppressed=true `≥ 0`
`notes`	`string \| null`	Free-form notes attached when the entry was added

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/suppression/check \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "+15555550100"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/suppression/check",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'phone': '+15555550100'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/check",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/check",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"phone": "+15555550100"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/suppression/check", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/suppression/check"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"phone\": \"+15555550100\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/suppression/check");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"phone\": \"+15555550100\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/suppression/check");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"phone\": \"+15555550100\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/suppression/check")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"phone": "+15555550100"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/suppression/check")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"phone": "+15555550100"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.20sms.suppression.list

GET /v1/sms/suppression/list

Paginated list of suppressed numbers.

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Paging cursor, obtained from next_cursor of the previous page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

SmsSuppressionListResult { items, total_count, next_cursor }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].phone`	`string`	E.164 phone.
`items[].reason`	`"user_request" \| "stop_reply" \| "carrier_block" \| "invalid" \| "manual"`	Reason for the current state or action
`items[].added_at`	`string`	ISO 8601 timestamp when this resource was added `format: date-time`
`items[].scope`	`"account"`	Scope of applicability for this resource
`items[].last_attempt_at`	`string \| null`	ISO 8601 timestamp of the most recent blocked send attempt, if any. `format: date-time`
`items[].attempt_count_blocked`	`integer`	Count of send attempts blocked by this suppression entry so far. `≥ 0`
`items[].notes`	`string \| null`	Free-form notes attached when the entry was added.
`count`	`integer \| null`	Total number of items across all pages `≥ 0`
`total_count`	`integer \| null`	Total number of items across all pages `≥ 0`
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/sms/suppression/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/suppression/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

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

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/sms/suppression/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/suppression/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/sms/suppression/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/suppression/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/suppression/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/sms/suppression/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.21sms.suppression.delete

POST /v1/sms/suppression/delete

Remove the number from the suppression list to resume sending.

Parameters

Name	Type	Required	Description
`phone`	`string`	Required	Phone number to remove (E.164 format).
`scope`	`"account"`	Optional	Removed suppression scope, such as account, global. `default: "account"`
`idempotency_key`	`string`	Optional	Deduplication key; same retry returns the same result.

Returns

SmsSuppressionRemoveResult { phone, removed }

Name	Type	Description
`phone`	`string`	E.164 phone targeted.
`deleted`	`boolean`	Whether the resource was successfully removed
`found`	`boolean`	Whether a matching entry existed

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/sms/suppression/delete \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "+15555550100"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/suppression/delete",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'phone': '+15555550100'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/delete",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/suppression/delete",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"phone": "+15555550100"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"phone": "+15555550100"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/sms/suppression/delete", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/sms/suppression/delete"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"phone\": \"+15555550100\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/sms/suppression/delete");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"phone\": \"+15555550100\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/sms/suppression/delete");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"phone\": \"+15555550100\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/sms/suppression/delete")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"phone": "+15555550100"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/sms/suppression/delete")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"phone": "+15555550100"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

Advanced: pin a vendor

By default infrai routes each call to the best available provider — you do not pick a vendor. As an escape hatch, this capability accepts an optional vendor parameter to pin one specific provider. Every live vendor for this capability is available in real time from the discovery endpoint for the capability id — see the discovery API.

GET /v1/discovery/{capability}

sms.send

sms.signature.create

sms.template.create

3. All capabilities

Every routed capability in this module — the complete public REST contract. The methods above are the guided walkthrough; this index is the full reference.

sms.batch.sendPOST /v1/sms/batch/send

Send a heterogeneous batch of SMS (each a full request) under one idempotency key, billed per message.

Parameters (2)

Name	Type	Required	Description
`messages`	`object[]`	Required	Up to 100 SmsSendRequest items. `1–100 items`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.cancelPOST /v1/sms/cancel/{id}

Cancel a scheduled or queued SMS that has not yet been dispatched.

Parameters (3)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.
`message_id`	`string`	Required	Id of the SMS message to cancel. `pattern: ^sms_[A-Za-z0-9]{20,}$`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.eventsGET /v1/sms/events/{id}

Retrieve the delivery event timeline for a single SMS message.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.inbound.listGET /v1/sms/inbound/list

List inbound (reply) SMS received on registered sender numbers, with pagination.

No request parameters.

sms.otpPOST /v1/sms/otp

Send a one-time passcode via SMS with gateway-managed OTP lifecycle.

Parameters (4)

Name	Type	Required	Description
`to`	`string`	Required	Destination phone number (E.164). `e.g. +15555550100`
`phone`	`string \| null`	Optional	Legacy alias for to.
`template`	`string \| null`	Optional	Message template containing {code}; defaults to 'Your verification code is {code}'.
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.resendPOST /v1/sms/resend/{id}

Resend an SMS, optionally retrying only the failed recipients.

Parameters (4)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.
`message_id`	`string`	Required	Unique identifier for this message `pattern: ^sms_[A-Za-z0-9]{20,}$`
`only_failed`	`boolean`	Optional	Re-dispatch only failed recipients; false resends the whole original recipient set. `default: true`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.sendPOST /v1/sms/send

Send an SMS message to one or more recipients (idempotent).

Parameters (12)

Name	Type	Required	Description
`to`	`string \| string[]`	Required	E.164 phone number or array of.
`body`	`string \| null`	Optional	Plain text body of the message
`from`	`string \| null`	Optional	Sender ID, phone number, or approved sign name to use when the vendor path supports it.
`template_id`	`string \| null`	Optional	Identifier of the template used for rendering
`template_vars`	`object \| null`	Optional	Variables to substitute in the template
`vendor`	`string \| null`	Optional	Pin to a specific vendor.
`mode`	`"default_vendor"`	Optional	Delivery mode or operation mode `default: "default_vendor"`
`scheduled_at`	`string \| null`	Optional	ISO 8601 timestamp when the resource is scheduled to activate `format: date-time`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`tags`	`string[]`	Optional	Tags for categorization and filtering
`route_class`	`"transactional" \| "otp" \| "marketing"`	Optional	SMS route class for delivery optimization `default: "transactional"`
`opt_in_proof_url`	`string \| null`	Optional	Required when route_class=marketing. `format: uri`

sms.signature.createPOST /v1/sms/signature/create

Create an SMS signature (required for China delivery) and submit it for review.

Parameters (5)

Name	Type	Required	Description
`name`	`string`	Required	Signature text shown as the bracketed prefix, e.g. 'Acme'.
`type`	`"company" \| "app" \| "website" \| "public_account" \| "store" \| "other"`	Optional	Signature usage scenario required by China vendors. `default: "company"`
`proof_url`	`string \| null`	Optional	URL to the authorization letter / business-license image required for brand review. `format: uri`
`remark`	`string \| null`	Optional	Note shown to the vendor reviewer.
`vendor`	`string \| null`	Optional	Pin the vendor to register at; otherwise the gateway picks per region.

sms.signature.deleteDELETE /v1/sms/signature/delete/{id}

Delete a registered SMS signature (China-route vendor pre-config); sends referencing it will be rejected.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.signature.getGET /v1/sms/signature/get/{id}

Retrieve a single SMS signature and its review status.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.signature.listGET /v1/sms/signature/list

List SMS signatures with pagination.

No request parameters.

sms.statusGET /v1/sms/status/{id}

Query the delivery status of an SMS message by ID.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.suppression.addPOST /v1/sms/suppression/add

Add a phone number to the suppression (do-not-contact) list.

Parameters (5)

Name	Type	Required	Description
`phone`	`string`	Required	E.164 phone.
`reason`	`"user_request" \| "stop_reply" \| "carrier_block" \| "invalid" \| "manual"`	Optional	Reason for the current state or action `default: "manual"`
`scope`	`"account"`	Optional	Scope of applicability for this resource `default: "account"`
`notes`	`string \| null`	Optional	Free-text notes about this suppression
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.suppression.checkPOST /v1/sms/suppression/check

Check whether a phone number is suppressed before sending.

Parameters (2)

Name	Type	Required	Description
`phone`	`string`	Required	E.164 phone.
`scope`	`"account"`	Optional	Scope of applicability for this resource `default: "account"`

sms.suppression.deletePOST /v1/sms/suppression/delete

Remove a number from the suppression list to resume sending.

Parameters (3)

Name	Type	Required	Description
`phone`	`string`	Required	E.164 phone.
`scope`	`"account"`	Optional	Scope of applicability for this resource `default: "account"`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

sms.suppression.listGET /v1/sms/suppression/list

List suppressed phone numbers with pagination.

No request parameters.

sms.template.createPOST /v1/sms/template/create

Create a reusable SMS template with named variables.

Parameters (7)

Name	Type	Required	Description
`name`	`string`	Required	Human label for the template.
`body`	`string`	Required	Template text with {{var}} placeholders. Variable names may contain only letters, digits and underscore, and each variable may appear at most once.
`locale`	`string`	Optional	zh/cn locales trigger China-vendor review. `default: "en"`
`variables`	`string[]`	Optional	Declared placeholder names. If provided, it must exactly match the placeholders in body; final order is inferred from first appearance in body.
`vendor`	`string \| null`	Optional	Pin the vendor to register at; otherwise the gateway picks per region.
`message_type`	`"otp" \| "notification" \| "marketing"`	Optional	Template category. Infrai maps this to the vendor-native template type, e.g. Tencent SmsType: otp=3, notification=2, marketing=1. `default: "otp"`
`international`	`0 \| 1`	Optional	Tencent template region flag: 0 mainland China, 1 international/HK/Macau/Taiwan. `default: 1`

sms.template.deleteDELETE /v1/sms/template/delete/{id}

Delete a registered SMS message template (vendor pre-config); sends referencing it will be rejected.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.template.getGET /v1/sms/template/get/{id}

Retrieve a single SMS template.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

sms.template.listGET /v1/sms/template/list

List SMS templates with pagination.

No request parameters.

sms.verifyPOST /v1/sms/verify

Verify a user-submitted SMS one-time passcode.

Parameters (5)

Name	Type	Required	Description
`to`	`string`	Required	Phone number the OTP was issued to (E.164).
`phone`	`string \| null`	Optional	Legacy alias for to.
`code`	`string`	Required	The one-time code to verify.
`otp`	`string \| null`	Optional	Legacy alias for code.
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

4. End-to-end example

A production-style walkthrough of this module: configure once, then run the flow. It exercises most of the module's APIs.

A copy-paste-runnable single-file Python program (stdlib only, no SDK): set your INFRAI_API_KEY, run it, and walk this module's core flow with REAL billed calls — later steps reuse real fields returned by earlier ones. The 12-line helper is the entire integration.

python

#!/usr/bin/env python3
"""Infrai · sms — runnable real-app example (single file, zero deps).

Copy this file, set your key, run it: every step is a REAL call to
api.infrai.cc, billed at the real (tiny) per-call price, printing the
live JSON response. Get a key at https://infrai.cc/login (Google/
GitHub sign-in grants $2 free credit); add funds at
https://infrai.cc/billing. No SDK — the 12-line helper below is the
entire integration."""
import json
import os
from urllib import error, request

KEY = os.environ.get("INFRAI_API_KEY") or "ifr_..."  # <- your key
BASE = "https://api.infrai.cc"


# Same raw HTTPS POST/GET as every per-method example on this page —
# wrapped once for reuse. There is nothing else to it: no SDK.
def infrai(method, path, body=None):
    req = request.Request(
        BASE + path, method=method,
        data=json.dumps(body).encode() if body is not None else None,
        headers={"Authorization": f"Bearer {KEY}",
                 "Content-Type": "application/json"})
    try:
        with request.urlopen(req, timeout=60) as r:
            return json.loads(r.read())
    except error.HTTPError as e:
        return json.loads(e.read())


def show(label, resp):
    print(f"\n== {label} ==")
    print(json.dumps(resp, indent=2, ensure_ascii=False))
    return resp


# 1) sms.otp — POST /v1/sms/otp · Send a one-time passcode via SMS with gateway-managed OTP lifecycle.
ask1 = input("Your phone number, intl format (+86...): ").strip()
r1 = show("sms.otp", infrai("POST", "/v1/sms/otp", {"to":ask1}))

# 2) sms.verify — POST /v1/sms/verify · Verify a user-submitted SMS one-time passcode.
ask2 = input("Enter the code you just received: ").strip()
r2 = show("sms.verify", infrai("POST", "/v1/sms/verify", {"to":ask1,"code":ask2}))

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

# 1) Auth: every call is a raw HTTPS request to the Infrai gateway carrying
#    only your project key. No SDK, no install.
#    Get your key: sign in with Google/GitHub at https://infrai.cc/login for a
#    project key + $2 free credit (email sign-in starts at $0). On 402
#    INSUFFICIENT_CREDIT, add funds at https://infrai.cc/billing (or POST
#    /v1/account/topup and open the returned checkout_url).
export INFRAI_API_KEY="ifr_..."   # from https://infrai.cc/login


# 2) sms.send
curl -X POST https://api.infrai.cc/v1/sms/send \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "sample"}'

# 3) sms.otp
curl -X POST https://api.infrai.cc/v1/sms/otp \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+15555550100"}'

# 4) sms.verify
curl -X POST https://api.infrai.cc/v1/sms/verify \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "sample", "code": "123456"}'

# 5) sms.status
curl -X GET https://api.infrai.cc/v1/sms/status/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 6) sms.batch.send
curl -X POST https://api.infrai.cc/v1/sms/batch/send \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"to": "sample"}]}'

# 7) sms.cancel
curl -X POST https://api.infrai.cc/v1/sms/cancel/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message_id": "hello"}'

# 8) sms.events
curl -X GET https://api.infrai.cc/v1/sms/events/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 9) sms.inbound.list
curl -X GET https://api.infrai.cc/v1/sms/inbound/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# 1) Auth: every call is a raw HTTPS request carrying only your project key.
#    No SDK to install — just the `requests` library.
import os, requests

BASE = "https://api.infrai.cc"
HEADERS = {
    "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    "Content-Type": "application/json",
}


# 2) sms.send
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/send",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 3) sms.otp
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/otp",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': '+15555550100'},
)
resp.raise_for_status()
print(resp.json())

# 4) sms.verify
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/verify",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'to': 'sample', 'code': '123456'},
)
resp.raise_for_status()
print(resp.json())

# 5) sms.status
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/status/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 6) sms.batch.send
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/batch/send",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'messages': [{'to': 'sample'}]},
)
resp.raise_for_status()
print(resp.json())

# 7) sms.cancel
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/sms/cancel/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'message_id': 'hello'},
)
resp.raise_for_status()
print(resp.json())

# 8) sms.events
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/events/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 9) sms.inbound.list
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/sms/inbound/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch().
const BASE = "https://api.infrai.cc";
const HEADERS = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) sms.send
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample"}),
  },
);
console.log(await resp.json());

// 3) sms.otp
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/otp",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+15555550100"}),
  },
);
console.log(await resp.json());

// 4) sms.verify
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/verify",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample", "code": "123456"}),
  },
);
console.log(await resp.json());

// 5) sms.status
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 6) sms.batch.send
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/batch/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"to": "sample"}]}),
  },
);
console.log(await resp.json());

// 7) sms.cancel
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
console.log(await resp.json());

// 8) sms.events
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/events/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 9) sms.inbound.list
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/inbound/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch(), typed.
const BASE = "https://api.infrai.cc";
const HEADERS: Record<string, string> = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) sms.send
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 3) sms.otp
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/otp",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "+15555550100"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 4) sms.verify
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/verify",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"to": "sample", "code": "123456"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 5) sms.status
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 6) sms.batch.send
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/batch/send",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"messages": [{"to": "sample"}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 7) sms.cancel
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"message_id": "hello"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 8) sms.events
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/events/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 9) sms.inbound.list
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/sms/inbound/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

5. Developer guides

Move from endpoint details to complete workflows, production patterns and troubleshooting guides verified against the live API.

SMS developer guides