틸코블렛 API 데모 페이지

▽Request

HEADER

Method: POST
Content-Type: application/json
API-KEY: API KEY (내정보 > API KEY)
ENC-KEY: API Key 생성 시 제공받은 '공개키'로 RSA 암호화 시킨 AES Secret key 값이며, AES Secret key는 고객님이 생성한 값입니다.

BODY

Json 형식으로 보기

Auth	Object
CertFile [필수]	String	암호화
KeyFile [필수]	String	암호화
CertPassword [필수]	String	암호화
AgentId	String	암호화
AgentPassword	String	암호화
DeptUserId	String	암호화
DeptUserPassword	String	암호화
UserName	String	암호화
IdentityNumber	String	암호화
AddressDetail [필수]	String	암호화
PhoneNumber_1 [필수]	String	암호화
PhoneNumber_2 [필수]	String	암호화
PhoneNumber_3 [필수]	String	암호화
IdentityView [필수]	String	암호화
UseType [필수]	String	암호화
UseDesc [필수]	String	암호화
inc_dtl_cd	String	암호화
inc_dtl_nm	String	암호화
Dong	String	암호화
DongCode	String	암호화
BldgMainNo	String	암호화
BldgSubNo	String	암호화
JihaYn	String	암호화
Office	String	암호화
OfficeCode	String	암호화
Depart	String	암호화
DepartCode	String	암호화
Charge	String	암호화
ChargeCode	String	암호화
FaxNum	String	암호화
TelNum	String	암호화
ProcIncCd	String	암호화
CappFee	String	암호화
OrglCappFee	String	암호화
DeptCd	String	암호화
ChrgerId	String	암호화
ChrgerNm	String	암호화
ChrgerEmail	String	암호화
SetlIncCd	String	암호화
IsJoint	String	암호화
MhighIncCd	String	암호화
BldgNo	String	암호화

▽Response

Result	Object
전체텍스트	String
PdfData	String
문서확인번호	String
지방세납세증명서	Object
발급번호	String
접수일시	String
처리기간	String
신고일	String
신청인_납세자	String
납세자	Object
성명_법인명	String
주민_법인_외국인_등록번호	String
주소_영업소	String
전화번호_휴대전화	String
증명서의사용목적	Object
대금수령	String
대금지급자	String
그밖의목적	String
그밖의목적_내용	String
징수유예등체납처분유예의명세List	List
유예종류	String
유예기간	String
과세연도	String
세목	String
납부기한	String
지방세	String
가산금	String
ApiTxKey	String
StatusSeq	Int32
ErrorCode	Int32
Message	String
ErrorLog	String
TargetCode	String
TargetMessage	String
PointBalance	String

▽Demo

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Security;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;

namespace UnitTest
{
	[TestClass]
	public class TestCase
	{
		string apiHost   = "https://dev.tilko.net";
		string apiKey    = "__API_KEY__";

// AES 암호화 함수
		public string aesEncrypt(byte[] key, byte[] iv, byte[] plainText)
		{
			byte[] ret = new byte[0];

using (RijndaelManaged aes = new RijndaelManaged())
			{
				aes.Key = key;
				aes.IV = iv;
				aes.Mode = CipherMode.CBC;
				aes.Padding = PaddingMode.PKCS7;

using (ICryptoTransform enc = aes.CreateEncryptor(aes.Key, aes.IV))
				{
					using (MemoryStream ms = new MemoryStream())
					{
						using (CryptoStream cs = new CryptoStream(ms, enc, CryptoStreamMode.Write))
						{
							cs.Write(plainText, 0, plainText.Length);
							cs.FlushFinalBlock();
							ret = ms.ToArray();
						}
					}
				}
				aes.Clear();
			}

return Convert.ToBase64String(ret);
		}

// AES 암호화 함수
		public string aesEncrypt(byte[] key, byte[] iv, string plainText)
		{
			byte[] ret		= new byte[0];

using (RijndaelManaged aes = new RijndaelManaged())
			{
				aes.Key				= key;
				aes.IV				= iv;
				aes.Mode			= CipherMode.CBC;
				aes.Padding			= PaddingMode.PKCS7;

using (ICryptoTransform enc = aes.CreateEncryptor(aes.Key, aes.IV))
				{
					using (MemoryStream ms = new MemoryStream())
					{
						using (CryptoStream cs = new CryptoStream(ms, enc, CryptoStreamMode.Write))
						{
							cs.Write(Encoding.UTF8.GetBytes(plainText), 0, Encoding.UTF8.GetBytes(plainText).Length);
							cs.FlushFinalBlock();
							ret	= ms.ToArray();
						}
					}
				}
				aes.Clear();
			}

return Convert.ToBase64String(ret);
		}

// RSA 암호화 함수
		public string rsaEncrypt(string publicKey, byte[] aesKey)
		{
			string encryptedData = "";

using (RSACryptoServiceProvider rsaCSP = importPublicKey(publicKey))
			{
				byte[] byteEncryptedData = rsaCSP.Encrypt(aesKey, false);
				encryptedData = Convert.ToBase64String(byteEncryptedData);
				rsaCSP.Dispose();
			}

return encryptedData;
		}

public static RSACryptoServiceProvider importPublicKey(string pem)
		{
			string PUBLIC_HEADER	= "-----BEGIN PUBLIC KEY-----";
			string PUBLIC_FOOTER	= "-----END PUBLIC KEY-----";

if (!pem.Contains(PUBLIC_HEADER))
			{
				pem = PUBLIC_HEADER + Environment.NewLine +
					  pem + Environment.NewLine +
					  PUBLIC_FOOTER;
			}

PemReader pr						= new PemReader(new StringReader(pem));
			AsymmetricKeyParameter publicKey	= (AsymmetricKeyParameter)pr.ReadObject();
			RSAParameters rsaParams				= DotNetUtilities.ToRSAParameters((RsaKeyParameters)publicKey);

RSACryptoServiceProvider csp		= new RSACryptoServiceProvider();
			csp.ImportParameters(rsaParams);

return csp;
		}

// RSA 공개키(Public Key) 조회 함수
		public string getPublicKey()
        {
			string rsaPublicKey	= "";

using (HttpClient httpClient = new HttpClient())
			{
				httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

// 틸코 인증 서버에 RSA 공개키 요청
				string url	= string.Format("{0}/api/Auth/GetPublicKey?APIkey={1}", apiHost, apiKey);
				using (var response = httpClient.GetAsync(url).Result)
				{
					var resContent	= response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
					JObject resJson	= JObject.Parse(resContent);

rsaPublicKey	= (string)resJson["PublicKey"].ToString();
				}
			}

return rsaPublicKey;
		}

public class Auth
		{
			public string UserId { get; set; }
		
			public string UserPassword { get; set; }
		}

[TestMethod]
		public void main()
		{
			// RSA Public Key 조회
			string rsaPublicKey		= getPublicKey();
			Debug.WriteLine("rsaPublicKey: " + rsaPublicKey);

// AES Secret Key 및 IV 생성
			byte[] aesKey			= new byte[16];
			new Random().NextBytes(aesKey);
			byte[] aesIv			= new byte[16] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

// AES Key를 RSA Public Key로 암호화
			string aesCipherKey		= rsaEncrypt(rsaPublicKey, aesKey);
			Debug.WriteLine("aesCipherKey: " + aesCipherKey);

// API URL 설정
			string url				= apiHost + "/api/v2.0/GovGeneral/_1310000005601";

// API 요청 파라미터 설정
			var paramObj	= {{REQ_JSON}};

string bodies	= JsonConvert.SerializeObject(paramObj);

// API 호출
			using (HttpClient httpClient = new HttpClient())
			{
				httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
				httpClient.DefaultRequestHeaders.Add("API-KEY", apiKey);
				httpClient.DefaultRequestHeaders.Add("ENC-KEY", aesCipherKey);

// 틸코 데이터 서버에 데이터 요청
				var reqContent = new StringContent(bodies, Encoding.UTF8, "application/json");
				using (var response = httpClient.PostAsync(url, reqContent).Result)
				{
					var resContent	= response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
					Debug.WriteLine("resContent: " + resContent);

// 바이너리 파일 저장(해당되는 경우에만)
					/*
					JObject resJson	= JObject.Parse(resContent);
					File.WriteAllBytes("D:\\result.bin", Convert.FromBase64String((string)resJson["Result"]["BinaryData"]));
					*/
				}
			}
		}
	}
}

package UnitTest;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class TestCase {

String apiHost	= "https://dev.tilko.net";
	String apiKey	= "__API_KEY__";

// AES 암호화 함수
	public String aesEncrypt(byte[] key, byte[] iv, byte[] plainText) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		Cipher cipher						= Cipher.getInstance("AES/CBC/PKCS5Padding");	// JAVA의 PKCS5Padding은 PKCS7Padding과 호환
		SecretKeySpec keySpec				= new SecretKeySpec(key, "AES");
		IvParameterSpec ivSpec				= new IvParameterSpec(iv);

cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
		byte[] byteEncryptedData			= cipher.doFinal(plainText);
		
		// Base64로 인코딩
		String encryptedData				= new String(Base64.getEncoder().encodeToString(byteEncryptedData));
		
		return encryptedData;
	}

// AES 암호화 함수
	public String aesEncrypt(byte[] key, byte[] iv, String plainText) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		Cipher cipher						= Cipher.getInstance("AES/CBC/PKCS5Padding");	// JAVA의 PKCS5Padding은 PKCS7Padding과 호환
		SecretKeySpec keySpec				= new SecretKeySpec(key, "AES");
		IvParameterSpec ivSpec				= new IvParameterSpec(iv);

cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
		byte[] byteEncryptedData			= cipher.doFinal(plainText.getBytes("UTF-8"));
		
		// Base64로 인코딩
		String encryptedData				= new String(Base64.getEncoder().encodeToString(byteEncryptedData));
		
		return encryptedData;
	}

// RSA 암호화 함수
	public static String rsaEncrypt(String rsaPublicKey, byte[] aesKey) throws NoSuchAlgorithmException, UnsupportedEncodingException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		String encryptedData				= null;
		
        KeyFactory keyFactory				= KeyFactory.getInstance("RSA");
        byte[] keyBytes						= Base64.getDecoder().decode(rsaPublicKey.getBytes("UTF-8"));
        X509EncodedKeySpec spec				= new X509EncodedKeySpec(keyBytes);
        PublicKey fileGeneratedPublicKey	= keyFactory.generatePublic(spec);
        RSAPublicKey key					= (RSAPublicKey)(fileGeneratedPublicKey);

// 만들어진 공개키객체를 기반으로 암호화모드로 설정하는 과정
		Cipher cipher						= Cipher.getInstance("RSA");
		cipher.init(Cipher.ENCRYPT_MODE, key);

// 평문을 암호화하는 과정
		byte[] byteEncryptedData			= cipher.doFinal(aesKey);
		
		// Base64로 인코딩
		encryptedData						= new String(Base64.getEncoder().encodeToString(byteEncryptedData));

return encryptedData;
	}

// RSA 공개키(Public Key) 조회 함수
	public String getPublicKey() throws IOException, ParseException {
		OkHttpClient client		= new OkHttpClient();
		
		Request request			= new Request.Builder()
									.url(apiHost + "/api/Auth/GetPublicKey?APIkey=" + apiKey)
									.header("Content-Type", "application/json").build();

Response response		= client.newCall(request).execute();
		String responseStr		= response.body().string();

JSONParser jsonParser	= new JSONParser();
		JSONObject jsonObject	= (JSONObject) jsonParser.parse(responseStr);
		
		String rsaPublicKey		= (String) jsonObject.get("PublicKey");

return rsaPublicKey;
	}

public static void main(String[] args) throws IOException, ParseException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
		TestCase tc				= new TestCase();

// RSA Public Key 조회
		String rsaPublicKey		= tc.getPublicKey();
		System.out.println("rsaPublicKey: " + rsaPublicKey);
		
		
		// AES Secret Key 및 IV 생성
		byte[] aesKey			= new byte[16];
		new Random().nextBytes(aesKey);
		
		byte[] aesIv			= new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

// AES Key를 RSA Public Key로 암호화
		String aesCipherKey		= rsaEncrypt(rsaPublicKey, aesKey);
		System.out.println("aesCipherKey: " + aesCipherKey);

// API URL 설정
		String url				= tc.apiHost + "/api/v2.0/GovGeneral/_1310000005601";
		
		
		// API 요청 파라미터 설정
		JSONObject json			= new JSONObject();

// API 호출
		OkHttpClient client		= new OkHttpClient.Builder()
									.connectTimeout(60, TimeUnit.SECONDS)
									.readTimeout(60, TimeUnit.SECONDS)
									.writeTimeout(60, TimeUnit.SECONDS)
									.build();
		
		Request request			= new Request.Builder()
									.url(url)
									.addHeader("API-KEY"			, tc.apiKey)
									.addHeader("ENC-KEY"			, aesCipherKey)
									.post(RequestBody.create(MediaType.get("application/json; charset=utf-8"), json.toJSONString())).build();

Response response		= client.newCall(request).execute();
		String responseStr		= response.body().string();
		System.out.println("responseStr: " + responseStr);
		
		
		// 바이너리 파일 저장(해당되는 경우에만)
		/*
		JSONParser parser		= new JSONParser();
		JSONObject responseJson	= (JSONObject) parser.parse(responseStr);
		
		JSONObject result		= (JSONObject) responseJson.get("Result");
		String binaryDataStr	= (String) result.get("BinaryData");
		
		byte[] binaryData = Base64.getDecoder().decode(binaryDataStr);
		try (OutputStream stream = new FileOutputStream("D:\\result.bin")) {
			stream.write(binaryData);
		}
		*/
	}

}

const Request   = require("sync-request");
const Crypto    = require("crypto");
const NodeRSA   = require("node-rsa");
const FS        = require("fs");

const apiHost   = "https://dev.tilko.net";
const apiKey    = "__API_KEY__";

// AES 암호화 함수
function aesEncrypt(key, iv, plainText) {
    const cipher    = Crypto.createCipheriv("aes-128-cbc", key, iv);
    
    let ret         = cipher.update(plainText, "utf8", "base64");
    ret             += cipher.final("base64");

return ret;
}

// RSA 암호화 함수
function rsaEncrypt(publicKey, aesKey, padding) {
    const key   = new NodeRSA("-----BEGIN PUBLIC KEY-----\n" + publicKey + "\n-----END PUBLIC KEY-----", {"encryptionScheme": padding});
    return key.encrypt(aesKey, "base64", "utf8");
}

// RSA 공개키(Public Key) 조회 함수
function getPublicKey() {
    const uri       = apiHost + "/api/Auth/GetPublicKey?APIkey=" + apiKey;
    const options   = {
        json: true,
    };
    
    const response      = Request("GET", uri, options);
    const rsaPublicKey  = JSON.parse(response.getBody("utf8")).PublicKey;
    return rsaPublicKey;
}

// RSA Public Key 조회
const rsaPublicKey  = getPublicKey(apiKey);
console.log("rsaPublicKey:", rsaPublicKey);

// AES Secret Key 및 IV 생성
const aesKey        = Crypto.randomBytes(16);
const aesIv         = Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);

// AES Key를 RSA Public Key로 암호화
let aesCipherKey    = Buffer.alloc(0);
aesCipherKey        = rsaEncrypt(rsaPublicKey, aesKey, "pkcs1");
console.log("aesCipherKey:", aesCipherKey);

// API URL 설정
const url       = apiHost + "/api/v2.0/GovGeneral/_1310000005601";

// API 요청 파라미터 설정
const options   = {
    headers: {
        "Content-Type"          : "application/json",
        "API-KEY"               : apiKey,
        "ENC-KEY"               : aesCipherKey
    },
    
    json: {{REQ_JSON}}
};

// API 호출
const res  = Request("POST", url, options);
console.log("res:", res.getBody("utf8"));

// 바이너리 파일 저장(해당되는 경우에만)
// FS.writeFileSync("D:\\result.bin", Buffer.from(JSON.parse(res.getBody("utf-8")).Result.BinaryData, "base64"));

<?php

set_include_path(get_include_path() . PATH_SEPARATOR . '../phpseclib1.0.19');
require_once('Crypt/RSA.php');

$apiHost   = "https://dev.tilko.net";
$apiKey    = "__API_KEY__";

// AES 암호화 함수
function aesEncrypt($aesKey, $aesIv, $plainText) {
    $ret = openssl_encrypt($plainText, 'AES-128-CBC', $aesKey, OPENSSL_RAW_DATA, $aesIv);	//default padding은 PKCS7 padding
    return base64_encode($ret);
}

// RSA 공개키(Public Key) 조회 함수
function getPublicKey($apiKey) {
    global $apiHost;

$url        = $apiHost . "api/Auth/GetPublicKey?APIkey=" . $apiKey;

$curl       = curl_init();

curl_setopt_array($curl, array(
        CURLOPT_URL             => $url,
        CURLOPT_RETURNTRANSFER  => true,
        CURLOPT_CUSTOMREQUEST   => "GET",
        CURLOPT_SSL_VERIFYHOST  => 0,
        CURLOPT_SSL_VERIFYPEER  => 0
    ));

$response   = curl_exec($curl);

curl_close($curl);

return json_decode($response, true)["PublicKey"];
}

// RSA Public Key 조회
$rsaPublicKey   = getPublicKey($apiKey);
print("rsaPublicKey:" . $rsaPublicKey);

// AES Secret Key 및 IV 생성
$aesKey     = random_bytes(16);
$aesIv      = str_repeat(chr(0), 16);

// AES Key를 RSA Public Key로 암호화
$rsa            = new Crypt_RSA();
$rsa->loadKey($rsaPublicKey);
$rsa->setEncryptionMode(CRYPT_RSA_ENCRYPTION_PKCS1);

$aesCipheredKey = $rsa->encrypt($aesKey);

// API URL 설정
$url        = $apiHost . "/api/v2.0/GovGeneral/_1310000005601";

// API 요청 파라미터 설정
$headers    = array(
    "Content-Type:"             . "application/json",
    "API-Key:"                  . $apiKey,
    "ENC-Key:"                  . base64_encode($aesCipheredKey),
);

$json			= array();

// API 호출
$curl   = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL             => $url,
    CURLOPT_RETURNTRANSFER  => true,
    CURLOPT_CUSTOMREQUEST   => "POST",
    CURLOPT_POSTFIELDS      => json_encode($json),
    CURLOPT_HTTPHEADER      => $headers,
    CURLOPT_VERBOSE         => false,
    CURLOPT_SSL_VERIFYHOST  => 0,
    CURLOPT_SSL_VERIFYPEER  => 0
));

$response   = curl_exec($curl);

curl_close($curl);

print($response);

// 바이너리 파일 저장(해당되는 경우에만)
// file_put_contents("D:\\result.bin", base64_decode(json_decode($response)->Result->BinaryData));

import os, json, base64
import requests
from Crypto import PublicKey
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5, AES

apiHost = 'https://dev.tilko.net'
apiKey  = '__API_KEY__'

# AES 암호화 함수
def aesEncrypt(key, iv, plainText):
    def pad(text):
        text_length     = len(text)
        amount_to_pad   = AES.block_size - (text_length % AES.block_size)

if amount_to_pad == 0:
            amount_to_pad = AES.block_size
            
        pad     = chr(amount_to_pad)

result  = None
        try:
            result  = text + str(pad * amount_to_pad).encode('utf-8')
        except Exception as e:
            result  = text + str(pad * amount_to_pad)

return result
    
    if type(plainText) == str:
        plainText = plainText.encode('utf-8')
    
    plainText   = pad(plainText)
    cipher      = AES.new(key, AES.MODE_CBC, iv)
    
    if(type(plainText) == bytes):
        return base64.b64encode(cipher.encrypt(plainText)).decode('utf-8')
    else:
        return base64.b64encode(cipher.encrypt(plainText.encode('utf-8'))).decode('utf-8')

# RSA 암호화 함수(RSA 공개키로 AES키 암호화)
def rsaEncrypt(publicKey, aesKey):
    rsa             = RSA.importKey(base64.b64decode(publicKey))
    cipher          = PKCS1_v1_5.new(rsa.publickey())
    aesCipherKey    = cipher.encrypt(aesKey)
    return aesCipherKey

# RSA 공개키(Public Key) 조회 함수
def getPublicKey():
    headers = {'Content-Type': 'application/json'}
    response = requests.get(apiHost + "/api/Auth/GetPublicKey?APIkey=" + apiKey, headers=headers)
    return response.json()['PublicKey']

# RSA Public Key 조회
rsaPublicKey    = getPublicKey()
print(f"rsaPublicKey: {rsaPublicKey}")

# AES Secret Key 및 IV 생성
aesKey          = os.urandom(16)
aesIv           = ('\x00' * 16).encode('utf-8')

# AES Key를 RSA Public Key로 암호화
aesCipherKey    = base64.b64encode(rsaEncrypt(rsaPublicKey, aesKey))
print(f"aesCipherKey: {aesCipherKey}")

# API URL 설정
url         = apiHost + "/api/v2.0/GovGeneral/_1310000005601";

# API 요청 파라미터 설정
options     = {
    "headers": {
        "Content-Type"          : "application/json",
        "API-KEY"               : apiKey,
        "ENC-KEY"               : aesCipherKey
    },
    "json": {{REQ_JSON}},
}

# API 호출
res         = requests.post(url, headers=options['headers'], json=options['json'])
print(f"res: {res.json()}")

# 결과 저장
with open(f"D:\\Temp\\result.txt", "w", encoding='utf-8') as f:
    f.write(res.text)

# 바이너리 파일 저장(해당되는 경우에만)
'''
with open("D:\\result.bin", "wb") as f:
    f.write(base64.b64decode(res.json()["Result"]["BinaryData"]))
'''

[공동인증용] 지방세 납세증명서 발급

[공동인증용] 지방세 납세증명서 발급

API 호출 주소

▽API 기본 가이드

API 프로세스

개발 가이드 문서

샘플 코드