证件照制作/检测接口

POST http(s)://api.shiliuai.com/api/id_photo/v1

{
  "code": 0,
  "msg": "OK",
  "msg_cn": "成功",
  "id": "xxxxxx",
  "result_base64": "/9j/4AAQSkZJRgABAQAAAQABAAD...（省略）",
  "layout_base64": "/9j/4AAQSkZJRgABAQAAAQABAAD...（可选，layout==1 时返回）",
  "info": {
    "qualified": true,
    "msg": "OK",
    "msg_cn": "合规",
    "width": 295,
    "height": 413
  },
  "advanced_info": {
    "qualified": true,
    "msg": "OK",
    "msg_cn": "高级合规"
  },
  "request_id": "req_xxxxxxxx"
}

# -*- coding: utf-8 -*-
import requests
import base64
import cv2
import json
import numpy as np

api_key = '******'  # 你的API KEY
file_path = '...'  # 图片路径

with open(file_path, 'rb') as fp:
    photo_base64 = base64.b64encode(fp.read()).decode('utf8')

url = 'http(s)://api.shiliuai.com/api/id_photo/v1'
headers = {'APIKEY': api_key, "Content-type": "application/json"}
data = {
    "base64": photo_base64,
    "bgColor": "FFFFFF",
    "dpi": 300,
    "mmHeight": 35,
    "mmWidth": 25
}

response = requests.post(url=url, headers=headers, json=data)
response = json.loads(response.content)
"""
成功：{'code': 0, 'msg': 'OK', 'msg_cn': '成功', 'id': id, 'result_base64': result_base64}
or
失败：{'code': error_code, 'msg': error_msg, 'msg_cn': 错误信息}
"""
result_base64 = response.get('result_base64', '')
img_id = response.get('id', '')
file_bytes = base64.b64decode(result_base64) if result_base64 else b''
if file_bytes:
    with open('result.jpg', 'wb') as f:
        f.write(file_bytes)

    image = np.asarray(bytearray(file_bytes), dtype=np.uint8)
    image = cv2.imdecode(image, cv2.IMREAD_COLOR)
    cv2.imshow('result', image)
    cv2.waitKey(0)

# 同一张图片，参数改变，再次请求（复用 id）
data2 = {
    "id": img_id,
    "bgColor": "FF0000",
    "dpi": 300,
    "pxHeight": 640,
    "pxWidth": 480
}
response2 = requests.post(url=url, headers=headers, json=data2)
response2 = json.loads(response2.content)

<?php
$url = "http(s)://api.shiliuai.com/api/id_photo/v1";
$method = "POST";
$apikey = "******";
$header = array();
array_push($header, "APIKEY:" . $apikey);
array_push($header, "Content-Type:application/json");

$file_path = "...";
$handle = fopen($file_path, "r");
$photo = fread($handle, filesize($file_path));
fclose($handle);
$photo_base64 = base64_encode($photo);

$data = array(
  "base64"=> $photo_base64,
  "bgColor"=>"FFFFFF",
  "dpi"=>300,
  "mmHeight"=>35,
  "mmWidth"=>25
);
$post_data = json_encode($data);

$curl = curl_init();
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
curl_setopt($curl, CURLOPT_POSTFIELDS, $post_data);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, false);

$response = curl_exec($curl);
var_dump($response);

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.util.Base64;
import org.json.JSONObject;

public class IDPhotoAPIExample {

    public static void main(String[] args) {
        String apiKey = "******"; // 你的API KEY
        String filePath = "path/to/your/image.jpg"; // 图片路径

        try {
            // 读取图片并编码为 Base64
            byte[] fileBytes = Files.readAllBytes(new File(filePath).toPath());
            String photoBase64 = Base64.getEncoder().encodeToString(fileBytes);

            // API 请求的 URL
            String apiUrl = "http(s)://api.shiliuai.com/api/id_photo/v1";

            // 请求参数 (初次请求)
            JSONObject requestData = new JSONObject();
            requestData.put("base64", photoBase64);
            requestData.put("bgColor", "FFFFFF");
            requestData.put("dpi", 300);
            requestData.put("mmHeight", 35);
            requestData.put("mmWidth", 25);

            // 发送 POST 请求
            JSONObject response = sendPostRequest(apiUrl, apiKey, requestData);

            // 检查响应是否成功
            if (response.getInt("code") == 0) {
                String resultBase64 = response.getString("result_base64");
                String id = response.getString("id");

                // 解码并保存图片
                byte[] resultBytes = Base64.getDecoder().decode(resultBase64);
                try (FileOutputStream fos = new FileOutputStream("result.jpg")) {
                    fos.write(resultBytes);
                }

                System.out.println("图片生成成功，文件已保存为 result.jpg");

                // 同一张图片，参数改变，再次请求
                JSONObject newRequestData = new JSONObject();
                newRequestData.put("id", id);
                newRequestData.put("bgColor", "FF0000");
                newRequestData.put("dpi", 300);
                newRequestData.put("pxHeight", 640);
                newRequestData.put("pxWidth", 480);

                // 发送新的请求
                JSONObject newResponse = sendPostRequest(apiUrl, apiKey, newRequestData);
                if (newResponse.getInt("code") == 0) {
                    String newResultBase64 = newResponse.getString("result_base64");
                    byte[] newResultBytes = Base64.getDecoder().decode(newResultBase64);
                    try (FileOutputStream fos = new FileOutputStream("result_red_bg.jpg")) {
                        fos.write(newResultBytes);
                    }
                    System.out.println("参数改变后的图片生成成功，文件已保存为 result_red_bg.jpg");
                } else {
                    System.out.println("新的请求失败: " + newResponse.getString("msg_cn"));
                }

            } else {
                System.out.println("初次请求失败: " + response.getString("msg_cn"));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 发送 POST 请求
    private static JSONObject sendPostRequest(String urlStr, String apiKey, JSONObject jsonData) throws IOException {
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("APIKEY", apiKey);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        // 写入请求数据
        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = jsonData.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        // 读取响应
        StringBuilder response = new StringBuilder();
        try (BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
        }

        return new JSONObject(response.toString());
    }
}

const fs = require('fs');
const fetch = require('node-fetch'); // 需安装：npm install node-fetch

const apiKey = '******'; // 你的API KEY
const filePath = 'path/to/your/image.jpg'; // 图片路径

(async () => {
  try {
    // 读取图片并编码为 Base64
    const fileBuffer = fs.readFileSync(filePath);
    const photoBase64 = fileBuffer.toString('base64');

    // API 请求的 URL
    const apiUrl = 'http(s)://api.shiliuai.com/api/id_photo/v1';

    // 请求参数 (初次请求)
    const requestData = {
      base64: photoBase64,
      bgColor: "FFFFFF",
      dpi: 300,
      mmHeight: 35,
      mmWidth: 25
    };

    // 发送 POST 请求
    let response = await fetch(apiUrl, {
      method: 'POST',
      headers: {
        'APIKEY': apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(requestData)
    });

    let responseData = await response.json();

    // 检查响应是否成功
    if (responseData.code === 0) {
      const resultBase64 = responseData.result_base64;
      const id = responseData.id;

      // 解码并保存图片
      const resultBuffer = Buffer.from(resultBase64, 'base64');
      fs.writeFileSync('result.jpg', resultBuffer);
      console.log("图片生成成功，文件已保存为 result.jpg");

      // 同一张图片，参数改变，再次请求
      const newRequestData = {
        id: id,
        bgColor: "FF0000",
        dpi: 300,
        pxHeight: 640,
        pxWidth: 480
      };

      response = await fetch(apiUrl, {
        method: 'POST',
        headers: {
          'APIKEY': apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(newRequestData)
      });

      responseData = await response.json();

      if (responseData.code === 0) {
        const newResultBase64 = responseData.result_base64;
        const newResultBuffer = Buffer.from(newResultBase64, 'base64');
        fs.writeFileSync('result_red_bg.jpg', newResultBuffer);
        console.log("参数改变后的图片生成成功，文件已保存为 result_red_bg.jpg");
      } else {
        console.error("新的请求失败:", responseData.msg_cn);
      }

    } else {
      console.error("初次请求失败:", responseData.msg_cn);
    }
  } catch (error) {
    console.error("发生错误:", error);
  }
})();

const request = require("request");
const fs = require("fs");

const apiKey = '******';
const filePath = 'path/to/your/image.jpg';
const apiUrl = 'http(s)://api.shiliuai.com/api/id_photo/v1';

function post(body, callback) {
  request({
    method: "POST",
    url: apiUrl,
    headers: {
      APIKEY: apiKey,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  }, callback);
}

function main() {
  const photoBase64 = fs.readFileSync(filePath).toString('base64');

  post({
    base64: photoBase64,
    bgColor: "FFFFFF",
    dpi: 300,
    mmHeight: 35,
    mmWidth: 25
  }, function (error, response, body) {
    if (error) {
      console.error(error);
      return;
    }
    let data = body;
    try {
      if (typeof body === 'string') data = JSON.parse(body);
    } catch (e) {}
    if (data.code !== 0) {
      console.error('初次请求失败:', data.msg_cn || data.msg);
      return;
    }

    fs.writeFileSync('result.jpg', Buffer.from(data.result_base64, 'base64'));
    console.log('图片生成成功，文件已保存为 result.jpg');

    post({
      id: data.id,
      bgColor: "FF0000",
      dpi: 300,
      pxHeight: 640,
      pxWidth: 480
    }, function (error2, response2, body2) {
      if (error2) {
        console.error(error2);
        return;
      }
      let data2 = body2;
      try {
        if (typeof body2 === 'string') data2 = JSON.parse(body2);
      } catch (e) {}
      if (data2.code === 0) {
        fs.writeFileSync('result_red_bg.jpg', Buffer.from(data2.result_base64, 'base64'));
        console.log('参数改变后的图片生成成功，文件已保存为 result_red_bg.jpg');
      } else {
        console.error('新的请求失败:', data2.msg_cn || data2.msg);
      }
    });
  });
}

main();

# 初次请求（将图片转为 base64 后填入）
curl -k 'http(s)://api.shiliuai.com/api/id_photo/v1' \
  -H 'APIKEY: 你的APIKEY' \
  -H 'Content-Type: application/json' \
  -d '{"base64":"图片base64编码","bgColor":"FFFFFF","dpi":300,"mmHeight":35,"mmWidth":25}'

# 同一张图片，参数改变后再次请求（id 为初次返回的值）
curl -k 'http(s)://api.shiliuai.com/api/id_photo/v1' \
  -H 'APIKEY: 你的APIKEY' \
  -H 'Content-Type: application/json' \
  -d '{"id":"初次返回的id","bgColor":"FF0000","dpi":300,"pxHeight":640,"pxWidth":480}'

using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var apiKey = "******";
        var filePath = "path/to/your/image.jpg";
        var url = "http(s)://api.shiliuai.com/api/id_photo/v1";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("APIKEY", apiKey);

        var photoBase64 = Convert.ToBase64String(File.ReadAllBytes(filePath));

        var request1 = new
        {
            base64 = photoBase64,
            bgColor = "FFFFFF",
            dpi = 300,
            mmHeight = 35,
            mmWidth = 25
        };

        var json1 = JsonSerializer.Serialize(request1);
        var res1 = await client.PostAsync(url, new StringContent(json1, Encoding.UTF8, "application/json"));
        var body1 = await res1.Content.ReadAsStringAsync();

        using var doc1 = JsonDocument.Parse(body1);
        var root1 = doc1.RootElement;
        if (root1.GetProperty("code").GetInt32() != 0)
        {
            var msg = root1.TryGetProperty("msg_cn", out var msgCn) ? msgCn.GetString() : root1.GetProperty("msg").GetString();
            Console.WriteLine("初次请求失败: " + msg);
            return;
        }

        var resultBase64 = root1.GetProperty("result_base64").GetString();
        var id = root1.GetProperty("id").GetString();
        File.WriteAllBytes("result.jpg", Convert.FromBase64String(resultBase64));
        Console.WriteLine("图片生成成功，文件已保存为 result.jpg");

        var request2 = new
        {
            id = id,
            bgColor = "FF0000",
            dpi = 300,
            pxHeight = 640,
            pxWidth = 480
        };

        var json2 = JsonSerializer.Serialize(request2);
        var res2 = await client.PostAsync(url, new StringContent(json2, Encoding.UTF8, "application/json"));
        var body2 = await res2.Content.ReadAsStringAsync();

        using var doc2 = JsonDocument.Parse(body2);
        var root2 = doc2.RootElement;
        if (root2.GetProperty("code").GetInt32() != 0)
        {
            var msg = root2.TryGetProperty("msg_cn", out var msgCn) ? msgCn.GetString() : root2.GetProperty("msg").GetString();
            Console.WriteLine("二次请求失败: " + msg);
            return;
        }

        var resultBase642 = root2.GetProperty("result_base64").GetString();
        File.WriteAllBytes("result_red_bg.jpg", Convert.FromBase64String(resultBase642));
        Console.WriteLine("参数改变后的图片生成成功，文件已保存为 result_red_bg.jpg");
    }
}

版本 2
.支持库 spec
.支持库 dp1

.子程序 证件照_API_示例
.局部变量 局_网址, 文本型
.局部变量 局_方式, 整数型
.局部变量 局_提交数据, 文本型
.局部变量 局_提交协议头, 文本型
.局部变量 局_结果, 字节集
.局部变量 局_返回, 文本型
.局部变量 图片数据, 字节集
.局部变量 base64图片, 文本型

图片数据 ＝ 读入文件 ("你的图片路径.jpg")
base64图片 ＝ 编码_BASE64编码 (图片数据)
局_提交数据 ＝ "{" ＋ #引号 ＋ "base64" ＋ #引号 ＋ ":" ＋ #引号 ＋ base64图片 ＋ #引号 ＋ "," ＋ #引号 ＋ "bgColor" ＋ #引号 ＋ ":" ＋ #引号 ＋ "FFFFFF" ＋ #引号 ＋ "," ＋ #引号 ＋ "dpi" ＋ #引号 ＋ ":300," ＋ #引号 ＋ "mmHeight" ＋ #引号 ＋ ":35," ＋ #引号 ＋ "mmWidth" ＋ #引号 ＋ ":25}"
局_网址 ＝ "http(s)://api.shiliuai.com/api/id_photo/v1"
局_方式 ＝ 1
局_提交协议头 ＝ "APIKEY: 你的APIKEY" ＋ #换行符 ＋ "Content-Type: application/json"
局_结果 ＝ 网页_访问_对象 (局_网址, 局_方式, 局_提交数据, , , 局_提交协议头, , , , , , , , , , , , , )
局_返回 ＝ 到文本 (编码_编码转换对象 (局_结果, , , ))
返回 (局_返回)

public static string Api_IdPhoto(Image image, string apiKey)
{
    string url = "http(s)://api.shiliuai.com/api/id_photo/v1";
    var headers = new Dictionary
    {
        {"Authorization", "APPCODE " + appcode},
        {"Content-Type", "application/json"}
    };
    string body = "{\"base64\":\"" + CustomHelp.ImageTobase64(image) + "\",\"bgColor\":\"FFFFFF\",\"dpi\":300,\"mmHeight\":35,\"mmWidth\":25}";
    return CustomHelp.HttpPost(url, body, headers);
}

Import "Encrypt.dll"

VBSBegin
' 启用错误处理
On Error Resume Next

Function Base64Encode(filePath)
    ' 检查文件是否存在
    Dim fso
    Set fso = CreateObject("Scripting.FileSystemObject")
    If Not fso.FileExists(filePath) Then
        Base64Encode = "ERROR:FileNotFound"
        Exit Function
    End If

    Set inStream = CreateObject("ADODB.Stream")
    inStream.Type = 1 ' adTypeBinary
    inStream.Open
    inStream.LoadFromFile filePath
    inStream.Position = 0

    Set dom = CreateObject("MSXML2.DOMDocument")
    Set elem = dom.createElement("tmp")
    elem.dataType = "bin.base64"
    elem.nodeTypedValue = inStream.Read
    Base64Encode = elem.Text

    inStream.Close
    ' 清理对象
    Set inStream = Nothing
    Set dom = Nothing
    Set elem = Nothing
    Set fso = Nothing
End Function

Function api_id_photo(apiKey, imgPath)
    ' 先检查文件是否存在,避免后续错误
    Dim fso
    Set fso = CreateObject("Scripting.FileSystemObject")
    If Not fso.FileExists(imgPath) Then
        api_id_photo = "ERROR: 图片文件不存在 - " & imgPath
        Exit Function
    End If

    ' 获取Base64并移除所有换行符(包括可能的回车换行)
    Dim base64Str
    base64Str = Base64Encode(imgPath)
    If Left(base64Str, 5) = "ERROR" Then
        api_id_photo = base64Str
        Exit Function
    End If

    ' 彻底清理换行和可能存在的空白字符
    base64Str = Replace(base64Str, vbCrLf, "")
    base64Str = Replace(base64Str, vbLf, "")
    base64Str = Replace(base64Str, vbCr, "")
    base64Str = Replace(base64Str, Chr(13), "")
    base64Str = Replace(base64Str, Chr(10), "")
    base64Str = Trim(base64Str) ' 去除首尾空白

    ' 构建JSON(使用CHR(34)避免引号冲突)
    Dim jsonBody
    jsonBody = "{" & Chr(34) & "base64" & Chr(34) & ":" & Chr(34) & base64Str & Chr(34) & "," & Chr(34) & "bgColor" & Chr(34) & ":" & Chr(34) & "FFFFFF" & Chr(34) & "," & Chr(34) & "dpi" & Chr(34) & ":300," & Chr(34) & "mmHeight" & Chr(34) & ":35," & Chr(34) & "mmWidth" & Chr(34) & ":25}"

    ' 创建HTTP对象
    Set http = CreateObject("MSXML2.XMLHTTP")
    http.Open "POST", "http(s)://api.shiliuai.com/api/id_photo/v1", False
    http.setRequestHeader "APIKEY", apiKey
    http.setRequestHeader "Content-Type", "application/json"

    ' 发送请求
    On Error Resume Next ' 再次确保捕获网络错误
    http.send jsonBody

    If Err.Number <> 0 Then
        api_id_photo = "HTTP发送错误: " & Err.Description
        Err.Clear
        Exit Function
    End If

    ' 检查HTTP状态
    If http.Status <> 200 Then
        api_id_photo = "HTTP状态异常: " & http.Status & " - " & http.statusText
        Exit Function
    End If

    api_id_photo = http.responseText
    Set http = Nothing
    Set fso = Nothing
End Function
VBSEnd

' 主程序部分
apiKey = "你的APIKEY"   ' 请替换为真实APIKEY
imgPath = "你的图片路径.jpg"   ' 请替换为真实图片路径

res = api_id_photo(apiKey, imgPath)

' 输出结果,如果出错则显示错误信息
If Left(res, 5) = "ERROR" Or Left(res, 6) = "HTTP状态" Or Left(res, 5) = "HTTP发" Then
    TracePrint "【错误】" & res
Else
    TracePrint "【响应】" & res
End If

Import "yd.luae"
Import "zm.luae"

Dim imagePath = "/sdcard/Pictures/test.png"
SnapShotEx imagePath

Function api_id_photo(apiKey, imagePath)
    Dim url = "http(s)://api.shiliuai.com/api/id_photo/v1"
    Dim body = "{""base64"":""" & yd.Base64EncodeFile(imagePath) & """,""bgColor"":""FFFFFF"",""dpi"":300,""mmHeight"":35,""mmWidth"":25}"
    Dim headers = {null}
    headers["APIKEY"] = apiKey
    headers["Content-Type"] = "application/json"
    Dim res = yd.HttpPost(url, body, headers)
    api_id_photo = yd.JsonDecode(res)
End Function

Dim apiKey = "你的APIKEY"
Dim res = api_id_photo(apiKey, imagePath)
TracePrint res["code"]

require("tsnet")
require "TSLib"
local ts = require("ts")
local json = ts.json

function readFileBase64(path)
    local f = io.open(path,"rb")
    if not f then return nil end
    local bytes = f:read("*all")
    f:close()
    return bytes:base64_encode()
end

function api_id_photo(apiKey, imagePath)
    local url = "http(s)://api.shiliuai.com/api/id_photo/v1"
    local body = json.encode({ base64 = readFileBase64(imagePath), bgColor = 'FFFFFF', dpi = 300, mmHeight = 35, mmWidth = 25 })
    local headers = {}
    headers["APIKEY"] = apiKey
    headers["Content-Type"] = "application/json"
    local resp = httpPost(url, body, { headers = headers })
    return json.decode(resp)
end

function api_id_photo(apiKey, imagePath)
    local url = "http(s)://api.shiliuai.com/api/id_photo/v1"
    local body = jsonLib.encode({ base64 = getFileBase64(imagePath), bgColor = 'FFFFFF', dpi = 300, mmHeight = 35, mmWidth = 25 })
    local headers = {}
    headers["APIKEY"] = apiKey
    headers["Content-Type"] = "application/json"
    local resp = httpPost(url, body, { headers = headers })
    return jsonLib.decode(resp)
end

function main()
    local request = image.requestScreenCapture(10000, 0)
    if not request then
        request = image.requestScreenCapture(10000, 0)
    end
    local apiKey = "你的APIKEY"
    local img = image.captureFullScreenEx()
    console.time("t")
    local res = api_id_photo(apiKey, img)
    logd(console.timeEnd("t"))
    logd(res.code)
end

function api_id_photo(apiKey, img)
    local url = "http(s)://api.shiliuai.com/api/id_photo/v1"
    local imgBase64 = image.toBase64Format(img, "jpg", 100)
    image.recycle(img)
    local body = JSON.stringify({ base64 = imgBase64, bgColor = 'FFFFFF', dpi = 300, mmHeight = 35, mmWidth = 25 })
    local params = {
        url = url,
        method = "POST",
        headers = {
            ["APIKEY"] = apiKey,
            ["Content-Type"] = "application/json"
        },
        requestBody = body
    }
    local res = http.request(params)
    return JSON.parse(res.body)
end