// POST /api/v1/auth/token
// API Key를 Authorization 헤더에 담아 Access Token을 발급받습니다.
define('BASE_URL', 'https://api.sms010.co.kr');

function issueToken($apiKey)
{
    $ch = curl_init(BASE_URL . '/api/v1/auth/token');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => '{}',
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $apiKey
        ],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) {
        echo 'cURL Error: ' . curl_error($ch);
        curl_close($ch);
        return null;
    }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) {
        return json_decode($response, true);
    }
    echo "Error: $httpCode - $response";
    return null;
}

// POST /api/v1/auth/revoke
// 발급된 Access Token을 폐기합니다.
function revokeToken($accessToken)
{
    $ch = curl_init(BASE_URL . '/api/v1/auth/revoke');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => '{}',
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $accessToken
        ],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

$apiKey = 'your_api_key';
$result = issueToken($apiKey);
if ($result) {
    // $result['result']['accessToken'] 으로 토큰 사용
    echo json_encode($result);
}
// 토큰 폐기
// $result = revokeToken('your_access_token');
				

// POST /api/v1/sms/send
// 문자 발송 API입니다.
define('BASE_URL', 'https://api.sms010.co.kr');

function sendSms($accessToken, $msgType, $message, $callbackNum, $recipients,
                 $title = null, $scheduleTime = null, $imgs = null)
{
    $data = [
        'msgType'     => $msgType,       // sms, lms, mms
        'message'     => $message,
        'callbackNum' => $callbackNum,
        'recipients'  => $recipients     // 수신번호 배열: ['01012345678', ...]
    ];
    if ($title !== null)        $data['title']        = $title;
    if ($scheduleTime !== null) $data['scheduleTime'] = $scheduleTime; // ISO 8601
    if ($imgs !== null)         $data['imgs']         = $imgs;         // MMS 전용

    $ch = curl_init(BASE_URL . '/api/v1/sms/send');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode($data),
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $accessToken
        ],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';

// SMS 즉시 발송
$result = sendSms($accessToken, 'sms', '테스트 메시지입니다.', '0211112222', ['01012345678']);

// LMS 예약 발송
// $result = sendSms($accessToken, 'lms', '장문 메시지 내용', '0211112222',
//                   ['01012345678'], '제목', '2026-12-01T10:00:00+09:00');

// MMS (이미지 포함)
// $imgs = [['name' => 'photo.jpg', 'data' => 'data:image/jpeg;base64,...']];
// $result = sendSms($accessToken, 'mms', '내용', '0211112222', ['01012345678'], '제목', null, $imgs);

if ($result) echo json_encode($result);

// POST /api/v1/alimtalk/send
define('BASE_URL', 'https://api.sms010.co.kr');

function sendAlimtalk($accessToken, $userId, $senderKey, $templateCode, $callbackNum,
                      $recipients, $scheduleTime = null, $fallback = null)
{
    $data = [
        'userId'       => $userId,
        'senderKey'    => $senderKey,
        'templateCode' => $templateCode,
        'callbackNum'  => $callbackNum,
        'recipients'   => $recipients
        // 각 recipient: ['phone' => '01012345678', 'variables' => ['이름' => '홍길동']]
    ];
    if ($scheduleTime !== null) $data['scheduleTime'] = $scheduleTime;
    if ($fallback !== null)     $data['fallback']     = $fallback;

    $ch = curl_init(BASE_URL . '/api/v1/alimtalk/send');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode($data, JSON_UNESCAPED_UNICODE),
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'Authorization: Bearer ' . $accessToken
        ],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';
$recipients  = [
    ['phone' => '01012345678', 'variables' => ['이름' => '홍길동', '주문번호' => 'A12345']]
];
$result = sendAlimtalk($accessToken, 'your_user_id', 'your_sender_key', 'TMPL_001', '0211112222', $recipients);
// 대체문자: $fallback = ['enabled' => true, 'type' => 1, 'callbackNum' => '0211112222'];
if ($result) echo json_encode($result, JSON_UNESCAPED_UNICODE);
            

// GET /api/v1/alimtalk/profiles
define('BASE_URL', 'https://api.sms010.co.kr');

function getProfiles($accessToken)
{
    $ch = curl_init(BASE_URL . '/api/v1/alimtalk/profiles');
    curl_setopt_array($ch, [
        CURLOPT_HTTPGET        => true,
        CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $accessToken],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';
$result = getProfiles($accessToken);
// $result['result']['profiles'][0]['senderKey'] 로 senderKey 확인
if ($result) echo json_encode($result, JSON_UNESCAPED_UNICODE);

define('BASE_URL', 'https://api.sms010.co.kr');

// ① GET /api/v1/alimtalk/templates  (목록)
function getTemplates($accessToken, $senderKey, $approvedOnly = false)
{
    $query = http_build_query(['senderKey' => $senderKey, 'approvedOnly' => $approvedOnly ? 'true' : 'false']);
    $ch = curl_init(BASE_URL . '/api/v1/alimtalk/templates?' . $query);
    curl_setopt_array($ch, [CURLOPT_HTTPGET => true, CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $accessToken], CURLOPT_RETURNTRANSFER => true, CURLOPT_CONNECTTIMEOUT => 5, CURLOPT_TIMEOUT => 10]);
    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response"; return null;
}

// ② GET /api/v1/alimtalk/templates/:templateCode  (상세)
function getTemplateDetail($accessToken, $templateCode, $senderKey)
{
    $url = BASE_URL . '/api/v1/alimtalk/templates/' . rawurlencode($templateCode) . '?' . http_build_query(['senderKey' => $senderKey]);
    $ch = curl_init($url);
    curl_setopt_array($ch, [CURLOPT_HTTPGET => true, CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $accessToken], CURLOPT_RETURNTRANSFER => true, CURLOPT_CONNECTTIMEOUT => 5, CURLOPT_TIMEOUT => 10]);
    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response"; return null;
}

// ③ GET /api/v1/alimtalk/public-templates  (공용 목록)
function getPublicTemplates($accessToken, $keyword = null, $category = null)
{
    $params = [];
    if ($keyword  !== null) $params['keyword']  = $keyword;
    if ($category !== null) $params['category'] = $category;
    $url = BASE_URL . '/api/v1/alimtalk/public-templates' . ($params ? '?' . http_build_query($params) : '');
    $ch = curl_init($url);
    curl_setopt_array($ch, [CURLOPT_HTTPGET => true, CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $accessToken], CURLOPT_RETURNTRANSFER => true, CURLOPT_CONNECTTIMEOUT => 5, CURLOPT_TIMEOUT => 10]);
    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response"; return null;
}

// ④ GET /api/v1/alimtalk/public-templates/:templateCode  (공용 상세)
function getPublicTemplateDetail($accessToken, $templateCode)
{
    $ch = curl_init(BASE_URL . '/api/v1/alimtalk/public-templates/' . rawurlencode($templateCode));
    curl_setopt_array($ch, [CURLOPT_HTTPGET => true, CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $accessToken], CURLOPT_RETURNTRANSFER => true, CURLOPT_CONNECTTIMEOUT => 5, CURLOPT_TIMEOUT => 10]);
    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch);
    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response"; return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';

$list   = getTemplates($accessToken, 'your_sender_key');           // ① 전체 목록
$listOk = getTemplates($accessToken, 'your_sender_key', true);     // ① 승인된 것만
$detail = getTemplateDetail($accessToken, 'TMPL_001', 'your_sender_key'); // ②
$pub    = getPublicTemplates($accessToken);                        // ③ 전체
$pubKw  = getPublicTemplates($accessToken, '주문');                // ③ 키워드
$pubDtl = getPublicTemplateDetail($accessToken, 'PUBLIC=490e99780198dd779812266'); // ④

if ($list) echo json_encode($list, JSON_UNESCAPED_UNICODE);

// GET /api/v1/account/cash
define('BASE_URL', 'https://api.sms010.co.kr');

function getCash($accessToken)
{
    $ch = curl_init(BASE_URL . '/api/v1/account/cash');
    curl_setopt_array($ch, [
        CURLOPT_HTTPGET        => true,
        CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $accessToken],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';
$result = getCash($accessToken);
// remainingSmsCount / remainingLmsCount / remainingMmsCount / remainingAlimtalkCount
if ($result) echo json_encode($result);

// DELETE /api/v1/messages/scheduled/{groupCode}
define('BASE_URL', 'https://api.sms010.co.kr');

function cancelScheduled($accessToken, $groupCode)
{
    $url = BASE_URL . '/api/v1/messages/scheduled/' . rawurlencode($groupCode);
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => 'DELETE',
        CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $accessToken],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
// groupCode는 발송 응답의 result.groupCode 값
$accessToken = 'your_access_token';
$result = cancelScheduled($accessToken, '202606151200_XXXXX');
if ($result) echo json_encode($result);
                

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// POST /api/v1/auth/token
// Authorization: Bearer {apiKey} 헤더로 Access Token을 발급받습니다.
public class ApiToken {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode issueToken(String apiKey) {
        try {
            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/auth/token"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + apiKey)
                .timeout(Duration.ofSeconds(10))
                .POST(HttpRequest.BodyPublishers.ofString("{}"))
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    // POST /api/v1/auth/revoke
    public static JsonNode revokeToken(String accessToken) {
        try {
            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/auth/revoke"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .POST(HttpRequest.BodyPublishers.ofString("{}"))
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String apiKey = "your_api_key";
        JsonNode result = issueToken(apiKey);
        if (result != null) {
            // result.path("result").path("accessToken").asText() 으로 토큰 추출
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
        }
        // 토큰 폐기: revokeToken("your_access_token");
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// POST /api/v1/sms/send
// 문자 발송 API입니다.
public class ApiSms {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode sendSms(String accessToken, String msgType,
                                   String message, String callbackNum,
                                   List recipients, String title,
                                   String scheduleTime, List> imgs) {
        try {
            Map data = new LinkedHashMap<>();
            data.put("msgType",     msgType);       // sms, lms, mms
            data.put("message",     message);
            data.put("callbackNum", callbackNum);
            data.put("recipients",  recipients);    // ["01012345678", ...]
            if (title != null)        data.put("title",        title);
            if (scheduleTime != null) data.put("scheduleTime", scheduleTime); // ISO 8601
            if (imgs != null)         data.put("imgs",         imgs);         // MMS 전용

            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/sms/send"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .POST(HttpRequest.BodyPublishers.ofString(
                    objectMapper.writeValueAsString(data)))
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String accessToken = "your_access_token";

        // SMS 즉시 발송
        JsonNode result = sendSms(accessToken, "sms", "테스트 메시지입니다.",
            "0211112222", List.of("01012345678"), null, null, null);

        // LMS 예약 발송
        // JsonNode result = sendSms(accessToken, "lms", "장문 내용", "0211112222",
        //     List.of("01012345678"), "제목", "2026-12-01T10:00:00+09:00", null);

        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// POST /api/v1/alimtalk/send
public class ApiAlimtalk {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode sendAlimtalk(String accessToken, String userId, String senderKey,
                                        String templateCode, String callbackNum,
                                        List> recipients,
                                        String scheduleTime, Map fallback) {
        try {
            Map data = new LinkedHashMap<>();
            data.put("userId",       userId);
            data.put("senderKey",    senderKey);
            data.put("templateCode", templateCode);
            data.put("callbackNum",  callbackNum);
            data.put("recipients",   recipients);
            // 각 recipient: {"phone": "01012345678", "variables": {"이름": "홍길동"}}
            if (scheduleTime != null) data.put("scheduleTime", scheduleTime);
            if (fallback != null)     data.put("fallback",     fallback);

            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/alimtalk/send"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .POST(HttpRequest.BodyPublishers.ofString(
                    objectMapper.writeValueAsString(data)))
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String accessToken = "your_access_token";
        Map vars = Map.of("이름", "홍길동", "주문번호", "A12345");
        Map recipient = Map.of("phone", "01012345678", "variables", vars);

        JsonNode result = sendAlimtalk(accessToken, "your_user_id", "your_sender_key", "TMPL_001",
            "0211112222", List.of(recipient), null, null);
        // 대체문자: fallback = Map.of("enabled", true, "type", 1, "callbackNum", "0211112222")
        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// GET /api/v1/alimtalk/profiles
public class ApiAlimtalkProfiles {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode getProfiles(String accessToken) {
        try {
            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/alimtalk/profiles"))
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .GET()
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String accessToken = "your_access_token";
        JsonNode result = getProfiles(accessToken);
        // result.path("result").path("profiles") 로 senderKey 목록 확인
        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

public class ApiTemplates {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper om = new ObjectMapper();

    static JsonNode get(String accessToken, String url) throws IOException, InterruptedException {
        HttpRequest req = HttpRequest.newBuilder().uri(URI.create(url))
            .header("Authorization", "Bearer " + accessToken)
            .timeout(Duration.ofSeconds(10)).GET().build();
        HttpResponse<String> res = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5)).build()
            .send(req, HttpResponse.BodyHandlers.ofString());
        if (res.statusCode() == 200) return om.readTree(res.body());
        System.err.println("Error: " + res.statusCode() + " - " + res.body()); return null;
    }

    // ① 템플릿 목록
    public static JsonNode getTemplates(String token, String senderKey, boolean approvedOnly) throws Exception {
        String q = "senderKey=" + URLEncoder.encode(senderKey, StandardCharsets.UTF_8) + "&approvedOnly=" + approvedOnly;
        return get(token, BASE_URL + "/api/v1/alimtalk/templates?" + q);
    }

    // ② 템플릿 상세
    public static JsonNode getTemplateDetail(String token, String templateCode, String senderKey) throws Exception {
        String path = URLEncoder.encode(templateCode, StandardCharsets.UTF_8);
        String q    = "senderKey=" + URLEncoder.encode(senderKey, StandardCharsets.UTF_8);
        return get(token, BASE_URL + "/api/v1/alimtalk/templates/" + path + "?" + q);
    }

    // ③ 공용 템플릿 목록
    public static JsonNode getPublicTemplates(String token, String keyword, String category) throws Exception {
        String q = "";
        if (keyword  != null) q += "&keyword="  + URLEncoder.encode(keyword,  StandardCharsets.UTF_8);
        if (category != null) q += "&category=" + URLEncoder.encode(category, StandardCharsets.UTF_8);
        return get(token, BASE_URL + "/api/v1/alimtalk/public-templates" + (q.isEmpty() ? "" : "?" + q.substring(1)));
    }

    // ④ 공용 템플릿 상세
    public static JsonNode getPublicTemplateDetail(String token, String templateCode) throws Exception {
        return get(token, BASE_URL + "/api/v1/alimtalk/public-templates/" + URLEncoder.encode(templateCode, StandardCharsets.UTF_8));
    }

    public static void main(String[] args) throws Exception {
        String token = "your_access_token";
        JsonNode list   = getTemplates(token, "your_sender_key", false);     // ①
        JsonNode detail = getTemplateDetail(token, "TMPL_001", "your_sender_key"); // ②
        JsonNode pub    = getPublicTemplates(token, null, null);              // ③ 전체
        JsonNode pubKw  = getPublicTemplates(token, "주문", null);           // ③ 키워드
        JsonNode pubDtl = getPublicTemplateDetail(token, "PUBLIC=490e99780198dd779812266"); // ④
        if (list != null) System.out.println(om.writerWithDefaultPrettyPrinter().writeValueAsString(list));
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// GET /api/v1/account/cash
public class ApiCash {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode getCash(String accessToken) {
        try {
            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/account/cash"))
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .GET()
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String accessToken = "your_access_token";
        JsonNode result = getCash(accessToken);
        // remainingSmsCount / remainingLmsCount / remainingMmsCount / remainingAlimtalkCount
        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// DELETE /api/v1/messages/scheduled/{groupCode}
public class ApiCancel {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode cancelScheduled(String accessToken, String groupCode) {
        try {
            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/messages/scheduled/" + groupCode))
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .DELETE()
                .build();

            HttpResponse response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        // groupCode는 발송 응답의 result.groupCode 값
        String accessToken = "your_access_token";
        JsonNode result = cancelScheduled(accessToken, "202606151200_XXXXX");
        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import requests
import json

# POST /api/v1/auth/token
# Authorization: Bearer {apiKey} 헤더로 Access Token을 발급받습니다.
BASE_URL = "https://api.sms010.co.kr"

def issue_token(api_key):
    try:
        response = requests.post(
            BASE_URL + "/api/v1/auth/token",
            headers={
                "Content-Type": "application/json",
                "Authorization": "Bearer " + api_key
            },
            json={}
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

def revoke_token(access_token):
    try:
        response = requests.post(
            BASE_URL + "/api/v1/auth/revoke",
            headers={
                "Content-Type": "application/json",
                "Authorization": "Bearer " + access_token
            },
            json={}
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    api_key = "your_api_key"
    result = issue_token(api_key)
    if result:
        # result["result"]["accessToken"] 으로 토큰 사용
        print(json.dumps(result, indent=4, ensure_ascii=False))
    # 토큰 폐기: revoke_token("your_access_token")
				

import requests
import json

# POST /api/v1/sms/send
# 문자 발송 API입니다.
BASE_URL = "https://api.sms010.co.kr"

def send_sms(access_token, msg_type, message, callback_num, recipients,
             title=None, schedule_time=None, imgs=None):
    data = {
        "msgType":     msg_type,       # sms, lms, mms
        "message":     message,
        "callbackNum": callback_num,
        "recipients":  recipients      # ["01012345678", ...]
    }
    if title is not None:         data["title"]        = title
    if schedule_time is not None: data["scheduleTime"] = schedule_time  # ISO 8601
    if imgs is not None:          data["imgs"]         = imgs           # MMS 전용

    try:
        response = requests.post(
            BASE_URL + "/api/v1/sms/send",
            headers={
                "Content-Type": "application/json",
                "Authorization": "Bearer " + access_token
            },
            json=data
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    access_token = "your_access_token"

    # SMS 즉시 발송
    result = send_sms(access_token, "sms", "테스트 메시지입니다.",
                      "0211112222", ["01012345678"])

    # LMS 예약 발송
    # result = send_sms(access_token, "lms", "장문 내용", "0211112222",
    #                   ["01012345678"], "제목", "2026-12-01T10:00:00+09:00")

    # MMS
    # imgs = [{"name": "photo.jpg", "data": "data:image/jpeg;base64,..."}]
    # result = send_sms(access_token, "mms", "내용", "0211112222",
    #                   ["01012345678"], "제목", None, imgs)

    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

import requests
import json

# POST /api/v1/alimtalk/send
BASE_URL = "https://api.sms010.co.kr"

def send_alimtalk(access_token, user_id, sender_key, template_code, callback_num,
                  recipients, schedule_time=None, fallback=None):
    data = {
        "userId":       user_id,
        "senderKey":    sender_key,
        "templateCode": template_code,
        "callbackNum":  callback_num,
        "recipients":   recipients
        # 각 recipient: {"phone": "01012345678", "variables": {"이름": "홍길동"}}
    }
    if schedule_time is not None: data["scheduleTime"] = schedule_time
    if fallback is not None:      data["fallback"]     = fallback

    try:
        response = requests.post(
            BASE_URL + "/api/v1/alimtalk/send",
            headers={
                "Content-Type": "application/json",
                "Authorization": "Bearer " + access_token
            },
            json=data
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    access_token = "your_access_token"
    recipients = [
        {"phone": "01012345678", "variables": {"이름": "홍길동", "주문번호": "A12345"}}
    ]
    result = send_alimtalk(access_token, "your_user_id", "your_sender_key", "TMPL_001",
                           "0211112222", recipients)
    # 대체문자: fallback = {"enabled": True, "type": 1, "callbackNum": "0211112222"}
    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

import requests
import json

# GET /api/v1/alimtalk/profiles
BASE_URL = "https://api.sms010.co.kr"

def get_profiles(access_token):
    try:
        response = requests.get(
            BASE_URL + "/api/v1/alimtalk/profiles",
            headers={"Authorization": "Bearer " + access_token}
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    access_token = "your_access_token"
    result = get_profiles(access_token)
    # result["result"]["profiles"][0]["senderKey"] 로 senderKey 확인
    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

import requests
import json

BASE_URL = "https://api.sms010.co.kr"

def _get(access_token, url, params=None):
    try:
        r = requests.get(url, headers={"Authorization": "Bearer " + access_token}, params=params)
        if r.status_code == 200: return r.json()
        print(f"Error: {r.status_code} - {r.text}"); return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}"); return None

# ① 템플릿 목록
def get_templates(access_token, sender_key, approved_only=False):
    return _get(access_token, BASE_URL + "/api/v1/alimtalk/templates",
                {"senderKey": sender_key, "approvedOnly": str(approved_only).lower()})

# ② 템플릿 상세
def get_template_detail(access_token, template_code, sender_key):
    return _get(access_token, f"{BASE_URL}/api/v1/alimtalk/templates/{template_code}",
                {"senderKey": sender_key})

# ③ 공용 템플릿 목록
def get_public_templates(access_token, keyword=None, category=None):
    params = {}
    if keyword  is not None: params["keyword"]  = keyword
    if category is not None: params["category"] = category
    return _get(access_token, BASE_URL + "/api/v1/alimtalk/public-templates", params or None)

# ④ 공용 템플릿 상세
def get_public_template_detail(access_token, template_code):
    return _get(access_token, f"{BASE_URL}/api/v1/alimtalk/public-templates/{template_code}")

if __name__ == "__main__":
    token = "your_access_token"
    list_   = get_templates(token, "your_sender_key")                  # ①
    detail  = get_template_detail(token, "TMPL_001", "your_sender_key") # ②
    pub     = get_public_templates(token)                               # ③ 전체
    pub_kw  = get_public_templates(token, keyword="주문")              # ③ 키워드
    pub_dtl = get_public_template_detail(token, "PUBLIC=490e99780198dd779812266") # ④
    if list_: print(json.dumps(list_, indent=4, ensure_ascii=False))
				

import requests
import json

# GET /api/v1/account/cash
BASE_URL = "https://api.sms010.co.kr"

def get_cash(access_token):
    try:
        response = requests.get(
            BASE_URL + "/api/v1/account/cash",
            headers={"Authorization": "Bearer " + access_token}
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    access_token = "your_access_token"
    result = get_cash(access_token)
    # remainingSmsCount / remainingLmsCount / remainingMmsCount / remainingAlimtalkCount
    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

import requests
import json

# DELETE /api/v1/messages/scheduled/{groupCode}
BASE_URL = "https://api.sms010.co.kr"

def cancel_scheduled(access_token, group_code):
    try:
        response = requests.delete(
            BASE_URL + "/api/v1/messages/scheduled/" + group_code,
            headers={"Authorization": "Bearer " + access_token}
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    # group_code는 발송 응답의 result.groupCode 값
    access_token = "your_access_token"
    result = cancel_scheduled(access_token, "202606151200_XXXXX")
    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

const BASE_URL = 'https://api.sms010.co.kr';
const API_KEY  = 'your_api_key';

// POST /api/v1/auth/token
// Authorization: Bearer {apiKey} 헤더로 Access Token을 발급받습니다.
function testIssueToken() {
  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/auth/token', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + API_KEY },
    payload: '{}',
    muteHttpExceptions: true
  });

  const body = JSON.parse(response.getContentText());
  const accessToken = body.result.accessToken;

  PropertiesService
    .getScriptProperties()
    .setProperty('ACCESS_TOKEN', accessToken);

  Logger.log('status=' + response.getResponseCode());
  Logger.log('accessToken=' + accessToken);
}

// POST /api/v1/auth/revoke
function testRevokeToken() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/auth/revoke', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + accessToken },
    payload: '{}',
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
}
				

const CALLBACK_NUM = '0211112222';
const RECIPIENTS   = ['01012345678'];

function testSendSms() {
  sendSms('sms', '테스트 메시지입니다.');
}

function testSendMmsWithDriveImage() {
  const file   = DriveApp.getFileById('your_google_drive_file_id');
  const bytes  = file.getBlob().getBytes();
  const base64 = Utilities.base64Encode(bytes);

  sendSms('mms', 'MMS 테스트입니다.', 'MMS 제목', null, [{
    name: file.getName(),
    data: 'data:image/jpeg;base64,' + base64
  }]);
}

// POST /api/v1/sms/send
// 문자 발송 API입니다.
function sendSms(msgType, message, title, scheduleTime, imgs) {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  const payload = {
    msgType:     msgType,
    message:     message,
    callbackNum: CALLBACK_NUM,
    recipients:  RECIPIENTS
  };
  if (title)        payload.title        = title;
  if (scheduleTime) payload.scheduleTime = scheduleTime; // ISO 8601
  if (imgs)         payload.imgs         = imgs;         // MMS 전용

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/sms/send', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + accessToken },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
}
				

// POST /api/v1/alimtalk/send
function testSendAlimtalk() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  const payload = {
    userId:       'your_user_id',
    senderKey:    'your_sender_key',
    templateCode: 'TMPL_001',
    callbackNum:  '0211112222',
    recipients: [
      { phone: '01012345678', variables: { '이름': '홍길동', '주문번호': 'A12345' } }
    ]
    // scheduleTime: '2026-12-01T10:00:00+09:00'
    // fallback: { enabled: true, type: 1, callbackNum: '0211112222' }
  };

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/alimtalk/send', {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + accessToken },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
}
				

// GET /api/v1/alimtalk/profiles
function testGetProfiles() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/alimtalk/profiles', {
    method: 'get',
    headers: { Authorization: 'Bearer ' + accessToken },
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
  // JSON.parse(response.getContentText()).result.profiles[0].senderKey 로 확인
}
				

function _gasGet(path) {
  const accessToken = PropertiesService.getScriptProperties().getProperty('ACCESS_TOKEN');
  const response = UrlFetchApp.fetch(BASE_URL + path, {
    method: 'get',
    headers: { Authorization: 'Bearer ' + accessToken },
    muteHttpExceptions: true
  });
  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
  return JSON.parse(response.getContentText());
}

// ① 템플릿 목록
function testGetTemplates() {
  _gasGet('/api/v1/alimtalk/templates?senderKey=your_sender_key');
  // 승인된 것만: ?senderKey=your_sender_key&approvedOnly=true
}

// ② 템플릿 상세
function testGetTemplateDetail() {
  _gasGet('/api/v1/alimtalk/templates/TMPL_001?senderKey=your_sender_key');
}

// ③ 공용 템플릿 목록
function testGetPublicTemplates() {
  _gasGet('/api/v1/alimtalk/public-templates');
  // 키워드 검색: _gasGet('/api/v1/alimtalk/public-templates?keyword=주문');
}

// ④ 공용 템플릿 상세
function testGetPublicTemplateDetail() {
  _gasGet('/api/v1/alimtalk/public-templates/PUBLIC%3D490e99780198dd779812266');
}
				

// GET /api/v1/account/cash
function testCash() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/account/cash', {
    method: 'get',
    headers: { Authorization: 'Bearer ' + accessToken },
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
  // remainingSmsCount / remainingLmsCount / remainingMmsCount / remainingAlimtalkCount
}
				

// DELETE /api/v1/messages/scheduled/{groupCode}
function testCancel() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  // groupCode는 발송 응답의 result.groupCode 값
  const groupCode = 'your_group_code';
  const response = UrlFetchApp.fetch(
    BASE_URL + '/api/v1/messages/scheduled/' + groupCode, {
    method: 'delete',
    headers: { Authorization: 'Bearer ' + accessToken },
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// POST /api/v1/auth/token
// Authorization: Bearer {apiKey} 헤더로 Access Token을 발급받습니다.
cJSON* api_issue_token(const char* api_key) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/auth/token", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", api_key);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{}");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

// POST /api/v1/auth/revoke
cJSON* api_revoke_token(const char* access_token) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/auth/revoke", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{}");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* api_key = "your_api_key";
    cJSON *result = api_issue_token(api_key);
    if (result) {
        // cJSON_GetObjectItem(cJSON_GetObjectItem(result,"result"),"accessToken")->valuestring
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    // 토큰 폐기: api_revoke_token("your_access_token");
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// POST /api/v1/sms/send
// 문자 발송 API입니다.
cJSON* api_send_sms(const char* access_token,
                    const char* msg_type, const char* message,
                    const char* callback_num,
                    const char** recipients, int recipient_count,
                    const char* title, const char* schedule_time) {
    cJSON *json = cJSON_CreateObject();
    cJSON_AddStringToObject(json, "msgType",     msg_type);
    cJSON_AddStringToObject(json, "message",     message);
    cJSON_AddStringToObject(json, "callbackNum", callback_num);
    cJSON *rcpts = cJSON_CreateArray();
    for (int i = 0; i < recipient_count; i++)
        cJSON_AddItemToArray(rcpts, cJSON_CreateString(recipients[i]));
    cJSON_AddItemToObject(json, "recipients", rcpts);
    if (title)         cJSON_AddStringToObject(json, "title",        title);
    if (schedule_time) cJSON_AddStringToObject(json, "scheduleTime", schedule_time);
    char *body = cJSON_PrintUnformatted(json);
    cJSON_Delete(json);

    CURL *curl = curl_easy_init();
    if (!curl) { free(body); return NULL; }
    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/sms/send", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);
    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    headers = curl_slist_append(headers, auth);
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(body); free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* access_token  = "your_access_token";
    const char* recipients[]  = {"01012345678"};

    // SMS 즉시 발송
    cJSON *result = api_send_sms(access_token, "sms", "테스트 메시지입니다.",
                                 "0211112222", recipients, 1, NULL, NULL);
    // LMS 예약: api_send_sms(access_token, "lms", "내용", "0211112222",
    //            recipients, 1, "제목", "2026-12-01T10:00:00+09:00");

    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// POST /api/v1/alimtalk/send
// recipients_json: JSON 배열 문자열 (예: [{"phone":"01012345678","variables":{"이름":"홍길동"}}])
cJSON* api_send_alimtalk(const char* access_token,
                          const char* user_id,
                          const char* sender_key, const char* template_code,
                          const char* callback_num, const char* recipients_json) {
    cJSON *json = cJSON_CreateObject();
    cJSON_AddStringToObject(json, "userId",       user_id);
    cJSON_AddStringToObject(json, "senderKey",    sender_key);
    cJSON_AddStringToObject(json, "templateCode", template_code);
    cJSON_AddStringToObject(json, "callbackNum",  callback_num);
    cJSON *rcpts = cJSON_Parse(recipients_json);
    if (rcpts) cJSON_AddItemToObject(json, "recipients", rcpts);
    char *body = cJSON_PrintUnformatted(json);
    cJSON_Delete(json);

    CURL *curl = curl_easy_init();
    if (!curl) { free(body); return NULL; }
    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/alimtalk/send", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);
    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json");
    headers = curl_slist_append(headers, auth);
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(body); free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* access_token = "your_access_token";
    const char* recipients_json =
        "[{\"phone\":\"01012345678\","
        "\"variables\":{\"이름\":\"홍길동\",\"주문번호\":\"A12345\"}}]";

    cJSON *result = api_send_alimtalk(access_token,
        "your_user_id",
        "your_sender_key", "TMPL_001", "0211112222", recipients_json);
    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// GET /api/v1/alimtalk/profiles
cJSON* api_get_profiles(const char* access_token) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/alimtalk/profiles", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* access_token = "your_access_token";
    cJSON *result = api_get_profiles(access_token);
    // cJSON_GetArrayItem(cJSON_GetObjectItem(cJSON_GetObjectItem(result,"result"),"profiles"),0)
    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };
static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s*n; struct APIResponse *resp = (struct APIResponse*)u;
    char *ptr = realloc(resp->data, resp->size+r+1); if(!ptr) return 0;
    resp->data=ptr; memcpy(&resp->data[resp->size],c,r); resp->size+=r; resp->data[resp->size]=0; return r;
}

static cJSON* do_get(const char* access_token, const char* url) {
    CURL *curl = curl_easy_init(); if (!curl) return NULL;
    struct APIResponse resp = {0}; char auth[512];
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);
    struct curl_slist *h = curl_slist_append(NULL, auth);
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, h);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);
    cJSON *result = NULL; CURLcode res = curl_easy_perform(curl);
    if (res == CURLE_OK) {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld\n", code);
    }
    curl_slist_free_all(h); curl_easy_cleanup(curl); free(resp.data);
    return result;
}

// ① 템플릿 목록
cJSON* api_get_templates(const char* token, const char* sender_key, int approved_only) {
    char url[512];
    snprintf(url, sizeof(url), "%s/api/v1/alimtalk/templates?senderKey=%s&approvedOnly=%s",
             BASE_URL, sender_key, approved_only ? "true" : "false");
    return do_get(token, url);
}

// ② 템플릿 상세
cJSON* api_get_template_detail(const char* token, const char* tmpl_code, const char* sender_key) {
    char url[512];
    snprintf(url, sizeof(url), "%s/api/v1/alimtalk/templates/%s?senderKey=%s",
             BASE_URL, tmpl_code, sender_key);
    return do_get(token, url);
}

// ③ 공용 템플릿 목록
cJSON* api_get_public_templates(const char* token, const char* keyword) {
    char url[512];
    if (keyword) snprintf(url, sizeof(url), "%s/api/v1/alimtalk/public-templates?keyword=%s", BASE_URL, keyword);
    else         snprintf(url, sizeof(url), "%s/api/v1/alimtalk/public-templates", BASE_URL);
    return do_get(token, url);
}

// ④ 공용 템플릿 상세
cJSON* api_get_public_template_detail(const char* token, const char* tmpl_code) {
    char url[512];
    snprintf(url, sizeof(url), "%s/api/v1/alimtalk/public-templates/%s", BASE_URL, tmpl_code);
    return do_get(token, url);
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* token = "your_access_token";
    cJSON *r;
    r = api_get_templates(token, "your_sender_key", 0);          // ①
    r = api_get_template_detail(token, "TMPL_001", "your_sender_key"); // ②
    r = api_get_public_templates(token, NULL);                    // ③ 전체
    r = api_get_public_templates(token, "주문");                  // ③ 키워드
    r = api_get_public_template_detail(token, "PUBLIC=490e99780198dd779812266"); // ④
    if (r) { char *out = cJSON_Print(r); puts(out); free(out); cJSON_Delete(r); }
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// GET /api/v1/account/cash
cJSON* api_get_cash(const char* access_token) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[256], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/account/cash", BASE_URL);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* access_token = "your_access_token";
    cJSON *result = api_get_cash(access_token);
    // remainingSmsCount / remainingLmsCount / remainingMmsCount / remainingAlimtalkCount
    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}
				

// GET /api/v1/messages
define('BASE_URL', 'https://api.sms010.co.kr');

function getHistory($accessToken, $type = 'all', $limit = 50, $from = null, $to = null)
{
    $params = ['type' => $type, 'limit' => $limit];
    if ($from !== null) $params['from'] = $from;
    if ($to   !== null) $params['to']   = $to;

    $ch = curl_init(BASE_URL . '/api/v1/messages?' . http_build_query($params));
    curl_setopt_array($ch, [
        CURLOPT_HTTPGET        => true,
        CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $accessToken],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT        => 10
    ]);

    $response = curl_exec($ch);
    if (curl_errno($ch)) { echo 'cURL Error: ' . curl_error($ch); curl_close($ch); return null; }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode == 200) return json_decode($response, true);
    echo "Error: $httpCode - $response";
    return null;
}

// --- 사용 예시 ---
$accessToken = 'your_access_token';

// 최근 50건 조회
$result = getHistory($accessToken);

// 기간 + 타입 조회
// $result = getHistory($accessToken, 'sms', 100,
//     '2026-06-01T00:00:00+09:00', '2026-06-30T23:59:59+09:00');

if ($result) echo json_encode($result, JSON_UNESCAPED_UNICODE);
				

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

// GET /api/v1/messages
public class ApiHistory {
    private static final String BASE_URL = "https://api.sms010.co.kr";
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static JsonNode getHistory(String accessToken, String type, int limit,
                                      String from, String to) {
        try {
            String query = "type=" + type + "&limit=" + limit;
            if (from != null) query += "&from=" + from;
            if (to   != null) query += "&to="   + to;

            HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/api/v1/messages?" + query))
                .header("Authorization", "Bearer " + accessToken)
                .timeout(Duration.ofSeconds(10))
                .GET()
                .build();

            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200)
                return objectMapper.readTree(response.body());
            System.err.println("Error: " + response.statusCode() + " - " + response.body());
            return null;

        } catch (IOException | InterruptedException e) {
            System.err.println("An error occurred: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String accessToken = "your_access_token";

        // 최근 50건 조회
        JsonNode result = getHistory(accessToken, "all", 50, null, null);

        // 기간 + 타입 조회
        // JsonNode result = getHistory(accessToken, "sms", 100,
        //     "2026-06-01T00:00:00+09:00", "2026-06-30T23:59:59+09:00");

        if (result != null)
            System.out.println(objectMapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(result));
    }
}
				

import requests
import json

# GET /api/v1/messages
BASE_URL = "https://api.sms010.co.kr"

def get_history(access_token, type='all', limit=50, from_date=None, to_date=None):
    params = {'type': type, 'limit': limit}
    if from_date is not None: params['from'] = from_date
    if to_date   is not None: params['to']   = to_date

    try:
        response = requests.get(
            BASE_URL + "/api/v1/messages",
            headers={"Authorization": "Bearer " + access_token},
            params=params
        )
        if response.status_code == 200:
            return response.json()
        print(f"Error: {response.status_code} - {response.text}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    access_token = "your_access_token"

    # 최근 50건 조회
    result = get_history(access_token)

    # 기간 + 타입 조회
    # result = get_history(access_token, 'sms', 100,
    #     '2026-06-01T00:00:00+09:00', '2026-06-30T23:59:59+09:00')

    if result:
        print(json.dumps(result, indent=4, ensure_ascii=False))
				

// GET /api/v1/messages
function testGetHistory() {
  const accessToken = PropertiesService
    .getScriptProperties()
    .getProperty('ACCESS_TOKEN');

  // 최근 50건 조회
  let params = 'type=all&limit=50';

  // 기간 + 타입 조회 (ISO 8601, +는 %2B로 인코딩)
  // params = 'type=sms&limit=100&from=2026-06-01T00:00:00%2B09:00&to=2026-06-30T23:59:59%2B09:00';

  const response = UrlFetchApp.fetch(BASE_URL + '/api/v1/messages?' + params, {
    method: 'get',
    headers: { Authorization: 'Bearer ' + accessToken },
    muteHttpExceptions: true
  });

  Logger.log('status=' + response.getResponseCode());
  Logger.log(response.getContentText());
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// GET /api/v1/messages
cJSON* api_get_history(const char* access_token, const char* type, int limit,
                       const char* from, const char* to) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[1024], auth[512];
    snprintf(url, sizeof(url), "%s/api/v1/messages?type=%s&limit=%d",
             BASE_URL, type ? type : "all", limit);
    if (from) { strncat(url, "&from=", sizeof(url)-strlen(url)-1);
                strncat(url, from,     sizeof(url)-strlen(url)-1); }
    if (to)   { strncat(url, "&to=",   sizeof(url)-strlen(url)-1);
                strncat(url, to,       sizeof(url)-strlen(url)-1); }
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s\n", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s\n", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    const char* access_token = "your_access_token";

    // 최근 50건 조회
    cJSON *result = api_get_history(access_token, "all", 50, NULL, NULL);

    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}
				

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <cjson/cJSON.h>

#define BASE_URL "https://api.sms010.co.kr"

struct APIResponse { char *data; size_t size; };

static size_t WriteCallback(void *c, size_t s, size_t n, void *u) {
    size_t r = s * n;
    struct APIResponse *resp = (struct APIResponse *)u;
    char *ptr = realloc(resp->data, resp->size + r + 1);
    if (!ptr) { puts("메모리 할당 실패"); return 0; }
    resp->data = ptr;
    memcpy(&resp->data[resp->size], c, r);
    resp->size += r;
    resp->data[resp->size] = 0;
    return r;
}

// DELETE /api/v1/messages/scheduled/{groupCode}
cJSON* api_cancel_scheduled(const char* access_token, const char* group_code) {
    CURL *curl = curl_easy_init();
    if (!curl) { puts("CURL 초기화 실패"); return NULL; }

    struct APIResponse resp = {0};
    char url[512], auth[512];
    snprintf(url,  sizeof(url),  "%s/api/v1/messages/scheduled/%s", BASE_URL, group_code);
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", access_token);

    struct curl_slist *headers = NULL;
    headers = curl_slist_append(headers, auth);

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5L);

    cJSON *result = NULL;
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        printf("CURL 오류: %s
", curl_easy_strerror(res));
    } else {
        long code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
        if (code == 200) result = cJSON_Parse(resp.data);
        else printf("Error: %ld - %s
", code, resp.data ? resp.data : "");
    }
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    free(resp.data);
    return result;
}

int main() {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    // group_code는 발송 응답의 result.groupCode 값
    const char* access_token = "your_access_token";
    cJSON *result = api_cancel_scheduled(access_token, "202606151200_XXXXX");
    if (result) {
        char *out = cJSON_Print(result);
        puts(out); free(out); cJSON_Delete(result);
    }
    curl_global_cleanup();
    return 0;
}