BEARER_TOKEN="your_jwt_token_here"
MERCHANT_ID="12345"

curl -X POST "https://kyc.sbx.moduluslabs.io/v2/onboard/${MERCHANT_ID}/files" \
  -H "Authorization: Bearer ${BEARER_TOKEN}" \
  -F "idsOfValidSignatories=@/path/to/valid_id_front.jpg" \
  -F "idsOfValidSignatoriesBack=@/path/to/valid_id_back.jpg" \
  -F "mayorsOrBusinessPermit=@/path/to/business_permit.pdf" \
  -F "storePhoto=@/path/to/store_photo.jpg"

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const BEARER_TOKEN = process.env.BEARER_TOKEN;
const MERCHANT_ID = '12345';

async function uploadOnboardingFiles() {
  try {
    const form = new FormData();

    // Add files to form data
    form.append('idsOfValidSignatories',
      fs.createReadStream('/path/to/valid_id_front.jpg'));
    form.append('idsOfValidSignatoriesBack',
      fs.createReadStream('/path/to/valid_id_back.jpg'));
    form.append('mayorsOrBusinessPermit',
      fs.createReadStream('/path/to/business_permit.pdf'));
    form.append('storePhoto',
      fs.createReadStream('/path/to/store_photo.jpg'));

    const response = await axios.post(
      `https://kyc.sbx.moduluslabs.io/v2/onboard/${MERCHANT_ID}/files`,
      form,
      {
        headers: {
          'Authorization': `Bearer ${BEARER_TOKEN}`,
          ...form.getHeaders()
        },
        maxContentLength: Infinity,
        maxBodyLength: Infinity
      }
    );

    console.log(' Files uploaded successfully!');
    console.log(`Uploaded ${response.data.files.length} file(s)`);

    response.data.files.forEach(file => {
      console.log(`  • ${file.fileType}: ${file.name} (ID: ${file.id})`);
    });
  } catch (error) {
    if (error.response) {
      console.error(' Upload failed:', error.response.data.message);
      if (error.response.data.details) {
        console.error('Details:', error.response.data.details);
      }
    } else {
      console.error(' Error:', error.message);
    }
  }
}

uploadOnboardingFiles();

import os
import requests

BEARER_TOKEN = os.getenv('BEARER_TOKEN')
MERCHANT_ID = '12345'

def upload_onboarding_files():
    url = f'https://kyc.sbx.moduluslabs.io/v2/onboard/{MERCHANT_ID}/files'

    headers = {
        'Authorization': f'Bearer {BEARER_TOKEN}'
    }

    # Prepare files for upload
    files = {
        'idsOfValidSignatories': open('/path/to/valid_id_front.jpg', 'rb'),
        'idsOfValidSignatoriesBack': open('/path/to/valid_id_back.jpg', 'rb'),
        'mayorsOrBusinessPermit': open('/path/to/business_permit.pdf', 'rb'),
        'storePhoto': open('/path/to/store_photo.jpg', 'rb')
    }

    try:
        response = requests.post(url, headers=headers, files=files)
        response.raise_for_status()

        data = response.json()
        print(' Files uploaded successfully!')
        print(f"Uploaded {len(data['files'])} file(s)")

        for file in data['files']:
            print(f"  • {file['fileType']}: {file.get('name', 'N/A')} (ID: {file['id']})")

    except requests.exceptions.HTTPError as error:
        error_data = error.response.json()
        print(f" Upload failed: {error_data.get('message', 'Unknown error')}")
        if 'details' in error_data:
            print(f"Details: {error_data['details']}")
    except Exception as error:
        print(f" Error: {str(error)}")
    finally:
        # Close all file handles
        for file in files.values():
            file.close()

if __name__ == '__main__':
    upload_onboarding_files()

<?php

$bearerToken = getenv('BEARER_TOKEN');
$merchantId = '12345';

$url = "https://kyc.sbx.moduluslabs.io/v2/onboard/{$merchantId}/files";

// Prepare file data
$files = [
    'idsOfValidSignatories' => new CURLFile('/path/to/valid_id_front.jpg', 'image/jpeg', 'valid_id_front.jpg'),
    'idsOfValidSignatoriesBack' => new CURLFile('/path/to/valid_id_back.jpg', 'image/jpeg', 'valid_id_back.jpg'),
    'mayorsOrBusinessPermit' => new CURLFile('/path/to/business_permit.pdf', 'application/pdf', 'business_permit.pdf'),
    'storePhoto' => new CURLFile('/path/to/store_photo.jpg', 'image/jpeg', 'store_photo.jpg')
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $files);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $bearerToken
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$data = json_decode($response, true);

if ($httpCode === 200) {
    echo " Files uploaded successfully!\n";
    echo "Uploaded " . count($data['files']) . " file(s)\n";

    foreach ($data['files'] as $file) {
        echo "  • {$file['fileType']}: " . ($file['name'] ?? 'N/A') . " (ID: {$file['id']})\n";
    }
} else {
    echo " Upload failed: {$data['message']}\n";
    if (isset($data['details'])) {
        echo "Details: " . json_encode($data['details']) . "\n";
    }
}

import java.io.File;
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.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONObject;
import org.json.JSONArray;

public class UploadOnboardingFiles {
    private static final String BEARER_TOKEN = System.getenv("BEARER_TOKEN");
    private static final String MERCHANT_ID = "12345";

    public static void main(String[] args) throws IOException, InterruptedException {
        String boundary = "----WebKitFormBoundary" + System.currentTimeMillis();
        List<byte[]> parts = new ArrayList<>();

        // Add files to multipart body
        addFilePart(parts, boundary, "idsOfValidSignatories",
            new File("/path/to/valid_id_front.jpg"), "image/jpeg");
        addFilePart(parts, boundary, "idsOfValidSignatoriesBack",
            new File("/path/to/valid_id_back.jpg"), "image/jpeg");
        addFilePart(parts, boundary, "mayorsOrBusinessPermit",
            new File("/path/to/business_permit.pdf"), "application/pdf");
        addFilePart(parts, boundary, "storePhoto",
            new File("/path/to/store_photo.jpg"), "image/jpeg");

        // Add closing boundary
        String closingBoundary = "\r\n--" + boundary + "--\r\n";
        parts.add(closingBoundary.getBytes());

        // Combine all parts
        byte[] body = combineBytes(parts);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://kyc.sbx.moduluslabs.io/v2/onboard/" + MERCHANT_ID + "/files"))
            .header("Authorization", "Bearer " + BEARER_TOKEN)
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofByteArray(body))
            .build();

        try {
            HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200) {
                JSONObject data = new JSONObject(response.body());
                JSONArray files = data.getJSONArray("files");

                System.out.println(" Files uploaded successfully!");
                System.out.println("Uploaded " + files.length() + " file(s)");

                for (int i = 0; i < files.length(); i++) {
                    JSONObject file = files.getJSONObject(i);
                    System.out.println("  • " + file.getString("fileType") + ": " +
                        file.optString("name", "N/A") + " (ID: " + file.getString("id") + ")");
                }
            } else {
                JSONObject error = new JSONObject(response.body());
                System.err.println(" Upload failed: " + error.getString("message"));
                if (error.has("details")) {
                    System.err.println("Details: " + error.get("details"));
                }
            }
        } catch (Exception e) {
            System.err.println(" Error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static void addFilePart(List<byte[]> parts, String boundary,
                                   String fieldName, File file, String mimeType)
                                   throws IOException {
        String header = "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"" + fieldName +
            "\"; filename=\"" + file.getName() + "\"\r\n" +
            "Content-Type: " + mimeType + "\r\n\r\n";

        parts.add(header.getBytes());
        parts.add(Files.readAllBytes(file.toPath()));
        parts.add("\r\n".getBytes());
    }

    private static byte[] combineBytes(List<byte[]> parts) {
        int totalLength = parts.stream().mapToInt(arr -> arr.length).sum();
        byte[] result = new byte[totalLength];
        int offset = 0;
        for (byte[] part : parts) {
            System.arraycopy(part, 0, result, offset, part.length);
            offset += part.length;
        }
        return result;
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

type FileMetadata struct {
    ID       string `json:"id"`
    Name     string `json:"name,omitempty"`
    FileType string `json:"fileType"`
}

type UploadResponse struct {
    Files []FileMetadata `json:"files"`
}

type ErrorResponse struct {
    StatusCode int         `json:"statusCode"`
    Message    string      `json:"message"`
    Error      string      `json:"error"`
    Details    interface{} `json:"details,omitempty"`
}

func main() {
    bearerToken := os.Getenv("BEARER_TOKEN")
    merchantID := "12345"

    // Prepare files to upload
    filePaths := map[string]string{
        "idsOfValidSignatories":     "/path/to/valid_id_front.jpg",
        "idsOfValidSignatoriesBack": "/path/to/valid_id_back.jpg",
        "mayorsOrBusinessPermit":    "/path/to/business_permit.pdf",
        "storePhoto":                "/path/to/store_photo.jpg",
    }

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // Add files to multipart form
    for fieldName, filePath := range filePaths {
        file, err := os.Open(filePath)
        if err != nil {
            fmt.Printf(" Error opening file %s: %v\n", filePath, err)
            return
        }
        defer file.Close()

        part, err := writer.CreateFormFile(fieldName, filepath.Base(filePath))
        if err != nil {
            fmt.Printf(" Error creating form file: %v\n", err)
            return
        }

        _, err = io.Copy(part, file)
        if err != nil {
            fmt.Printf(" Error copying file content: %v\n", err)
            return
        }
    }

    writer.Close()

    url := fmt.Sprintf("https://kyc.sbx.moduluslabs.io/v2/onboard/%s/files", merchantID)
    req, err := http.NewRequest("POST", url, body)
    if err != nil {
        fmt.Printf(" Error creating request: %v\n", err)
        return
    }

    req.Header.Set("Authorization", "Bearer "+bearerToken)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf(" Error making request: %v\n", err)
        return
    }
    defer resp.Body.Close()

    responseBody, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf(" Error reading response: %v\n", err)
        return
    }

    if resp.StatusCode == 200 {
        var uploadResponse UploadResponse
        if err := json.Unmarshal(responseBody, &uploadResponse); err != nil {
            fmt.Printf(" Error parsing response: %v\n", err)
            return
        }

        fmt.Println(" Files uploaded successfully!")
        fmt.Printf("Uploaded %d file(s)\n", len(uploadResponse.Files))

        for _, file := range uploadResponse.Files {
            name := file.Name
            if name == "" {
                name = "N/A"
            }
            fmt.Printf("  • %s: %s (ID: %s)\n", file.FileType, name, file.ID)
        }
    } else {
        var errorResponse ErrorResponse
        if err := json.Unmarshal(responseBody, &errorResponse); err != nil {
            fmt.Printf(" Error parsing error response: %v\n", err)
            return
        }

        fmt.Printf(" Upload failed: %s\n", errorResponse.Message)
        if errorResponse.Details != nil {
            fmt.Printf("Details: %v\n", errorResponse.Details)
        }
    }
}

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

class Program
{
    private static readonly string BEARER_TOKEN = Environment.GetEnvironmentVariable("BEARER_TOKEN");
    private static readonly string MERCHANT_ID = "12345";

    static async Task Main(string[] args)
    {
        try
        {
            using var client = new HttpClient();
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", BEARER_TOKEN);

            using var content = new MultipartFormDataContent();

            // Add files to multipart form
            var files = new Dictionary<string, string>
            {
                { "idsOfValidSignatories", "/path/to/valid_id_front.jpg" },
                { "idsOfValidSignatoriesBack", "/path/to/valid_id_back.jpg" },
                { "mayorsOrBusinessPermit", "/path/to/business_permit.pdf" },
                { "storePhoto", "/path/to/store_photo.jpg" }
            };

            foreach (var file in files)
            {
                var fileContent = new ByteArrayContent(File.ReadAllBytes(file.Value));
                fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(
                    GetMimeType(file.Value));
                content.Add(fileContent, file.Key, Path.GetFileName(file.Value));
            }

            var response = await client.PostAsync(
                $"https://kyc.sbx.moduluslabs.io/v2/onboard/{MERCHANT_ID}/files",
                content
            );

            var responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                using var doc = JsonDocument.Parse(responseBody);
                var filesArray = doc.RootElement.GetProperty("files");

                Console.WriteLine(" Files uploaded successfully!");
                Console.WriteLine($"Uploaded {filesArray.GetArrayLength()} file(s)");

                foreach (var fileElement in filesArray.EnumerateArray())
                {
                    var id = fileElement.GetProperty("id").GetString();
                    var fileType = fileElement.GetProperty("fileType").GetString();
                    var name = fileElement.TryGetProperty("name", out var nameElement)
                        ? nameElement.GetString()
                        : "N/A";

                    Console.WriteLine($"  • {fileType}: {name} (ID: {id})");
                }
            }
            else
            {
                using var doc = JsonDocument.Parse(responseBody);
                var message = doc.RootElement.GetProperty("message").GetString();

                Console.WriteLine($" Upload failed: {message}");

                if (doc.RootElement.TryGetProperty("details", out var details))
                {
                    Console.WriteLine($"Details: {details}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($" Error: {ex.Message}");
        }
    }

    private static string GetMimeType(string filePath)
    {
        var extension = Path.GetExtension(filePath).ToLowerInvariant();
        return extension switch
        {
            ".jpg" or ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".pdf" => "application/pdf",
            _ => "application/octet-stream"
        };
    }
}