curl -X POST "${BASE_URL}/api/v2/trans/bulk-upload" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Accept: application/json" \
  -F merchant_id=48290713 \
  -F '[email protected];type=text/plain'

import json
import os
import urllib.parse
import urllib.request
import uuid
from pathlib import Path

base_url = os.environ["BASE_URL"].rstrip("/")
url = base_url + "/api/v2/trans/bulk-upload"
headers = {"Accept": "application/json"}
headers["Authorization"] = "Bearer " + os.environ["ACCESS_TOKEN"]
fields = {
    "merchant_id": "48290713",
}
boundary = "----BillBuddy" + uuid.uuid4().hex
parts = []
for name, value in fields.items():
    parts.append((
        f'--{boundary}\r\n'
        f'Content-Disposition: form-data; name="{name}"\r\n\r\n'
        f'{value}\r\n'
    ).encode("utf-8"))
parts.append((
    f'--{boundary}\r\n'
    'Content-Disposition: form-data; name="file"; filename="payments.txt"\r\n'
    'Content-Type: text/plain\r\n\r\n'
).encode("utf-8"))
parts.append(Path("payments.txt").read_bytes())
parts.append(f'\r\n--{boundary}--\r\n'.encode("ascii"))
body = b"".join(parts)
headers["Content-Type"] = "multipart/form-data; boundary=" + boundary

request = urllib.request.Request(url, data=body, headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=30) as response:
    print(response.read().decode("utf-8"))

import { readFile } from "node:fs/promises";

const env = (name) => {
  const value = process.env[name];
  if (!value) throw new Error(`Missing environment variable: ${name}`);
  return value;
};
const baseUrl = env("BASE_URL").replace(/\/+$/, "");
const url = new URL(baseUrl + "/api/v2/trans/bulk-upload");
const headers = { Accept: "application/json" };
headers.Authorization = `Bearer ${env("ACCESS_TOKEN")}`;
const body = new FormData();
body.append("merchant_id", "48290713");
const file = await readFile("payments.txt");
body.append("file", new Blob([file], { type: "text/plain" }), "payments.txt");

const response = await fetch(url, {
  method: "POST",
  headers,
  body,
  signal: AbortSignal.timeout(30_000),
});
console.log(await response.text());

<?php
$env = static function (string $name): string {
    $value = getenv($name);
    if ($value === false || $value === '') {
        throw new RuntimeException("Missing environment variable: " . $name);
    }
    return $value;
};
$baseUrl = rtrim($env('BASE_URL'), '/');
$url = $baseUrl . "/api/v2/trans/bulk-upload";
$headers = ['Accept: application/json'];
$headers[] = 'Authorization: Bearer ' . $env('ACCESS_TOKEN');
$params = [
    "merchant_id" => "48290713",
];
$params['file'] = new CURLFile('payments.txt', 'text/plain', 'payments.txt');
$body = $params;

$curl = curl_init($url);
curl_setopt_array($curl, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => $body,
]);
$response = curl_exec($curl);
if ($response === false) {
    $error = curl_error($curl);
    curl_close($curl);
    throw new RuntimeException($error);
}
curl_close($curl);
echo $response, PHP_EOL;

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "strings"
    "time"
)

func mustEnv(name string) string {
    value := os.Getenv(name)
    if value == "" { panic("Missing environment variable: " + name) }
    return value
}

func main() {
    baseURL := strings.TrimRight(mustEnv("BASE_URL"), "/")
    endpoint := baseURL + "/api/v2/trans/bulk-upload"
    var body bytes.Buffer
    writer := multipart.NewWriter(&body)
    if err := writer.WriteField("merchant_id", "48290713"); err != nil { panic(err) }
    file, err := os.Open("payments.txt")
    if err != nil { panic(err) }
    defer file.Close()
    part, err := writer.CreateFormFile("file", "payments.txt")
    if err != nil { panic(err) }
    if _, err = io.Copy(part, file); err != nil { panic(err) }
    if err = writer.Close(); err != nil { panic(err) }
    req, err := http.NewRequest("POST", endpoint, &body)
    if err != nil { panic(err) }
    req.Header.Set("Accept", "application/json")
    req.Header.Set("Authorization", "Bearer " + mustEnv("ACCESS_TOKEN"))
    req.Header.Set("Content-Type", writer.FormDataContentType())
    client := &http.Client{Timeout: 30 * time.Second}
    response, err := client.Do(req)
    if err != nil { panic(err) }
    defer response.Body.Close()
    result, err := io.ReadAll(response.Body)
    if err != nil { panic(err) }
    fmt.Println(string(result))
}

import java.io.ByteArrayOutputStream;
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.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

public class Example {
    static String requireEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.isEmpty()) {
            throw new IllegalArgumentException("Missing environment variable: " + name);
        }
        return value;
    }

    public static void main(String[] args) throws Exception {
        String baseUrl = requireEnv("BASE_URL").replaceAll("/+$", "");
        String endpoint = baseUrl + "/api/v2/trans/bulk-upload";
        String boundary = "----BillBuddy" + UUID.randomUUID();
        ByteArrayOutputStream body = new ByteArrayOutputStream();
        body.write(("--" + boundary + "\r\n"
            + "Content-Disposition: form-data; name=\"merchant_id\"\r\n\r\n"
            + "48290713" + "\r\n").getBytes(StandardCharsets.UTF_8));
        body.write(("--" + boundary + "\r\n"
            + "Content-Disposition: form-data; name=\"file\"; filename=\"payments.txt\"\r\n"
            + "Content-Type: text/plain\r\n\r\n").getBytes(StandardCharsets.UTF_8));
        Files.copy(Path.of("payments.txt"), body);
        body.write(("\r\n--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8));
        HttpRequest.Builder builder = HttpRequest.newBuilder(URI.create(endpoint))
            .timeout(Duration.ofSeconds(30))
            .header("Accept", "application/json");
        builder.header("Authorization", "Bearer " + requireEnv("ACCESS_TOKEN"));
        builder.header("Content-Type", "multipart/form-data; boundary=" + boundary);
        HttpRequest request = builder.method("POST", HttpRequest.BodyPublishers.ofByteArray(body.toByteArray())).build();
        HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(30)).build();
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        System.out.println(response.body());
    }
}

require "net/http"
require "uri"

base_url = ENV.fetch("BASE_URL").sub(%r{/+$}, "")
uri = URI(base_url + "/api/v2/trans/bulk-upload")
params = {
  "merchant_id" => "48290713",
}
request = Net::HTTP::Post.new(uri)
request["Accept"] = "application/json"
request["Authorization"] = "Bearer " + ENV.fetch("ACCESS_TOKEN")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
http.open_timeout = 30
http.read_timeout = 30
File.open("payments.txt", "rb") do |file|
  fields = params.to_a
  fields << ["file", file, { filename: "payments.txt", content_type: "text/plain" }]
  request.set_form(fields, "multipart/form-data")
  puts http.request(request).body
end