Cargar y gestionar archivos de origen mediante la API

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files')
uri.query = URI.encode_www_form(file_tag_name: 'frontend', page: 1, per_page: 25)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'

response = http.request(request)
puts response.body

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}

params = {
    'file_tag_name': 'frontend',
    'page': 1,
    'per_page': 25
}

response = requests.get('https://app.ptc.wpml.org/api/v1/source_files',
                        headers=headers, params=params)
print(response.json())

<?php
$params = http_build_query([
    'file_tag_name' => 'frontend',
    'page' => 1,
    'per_page' => 25
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://app.ptc.wpml.org/api/v1/source_files?{$params}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

print_r(json_decode($response, true));
?>

import okhttp3.*;

OkHttpClient client = new OkHttpClient();

HttpUrl url = HttpUrl.parse("https://app.ptc.wpml.org/api/v1/source_files")
    .newBuilder()
    .addQueryParameter("file_tag_name", "frontend")
    .addQueryParameter("page", "1")
    .addQueryParameter("per_page", "25")
    .build();

Request request = new Request.Builder()
    .url(url)
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://app.ptc.wpml.org/api/v1/source_files", nil)

    q := req.URL.Query()
    q.Add("file_tag_name", "frontend")
    q.Add("page", "1")
    q.Add("per_page", "25")
    req.URL.RawQuery = q.Encode()

    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var response = await client.GetAsync("https://app.ptc.wpml.org/api/v1/source_files?file_tag_name=frontend&page=1&per_page=25");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

const axios = require('axios');

const response = await axios.get('https://app.ptc.wpml.org/api/v1/source_files', {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' },
  params: {
    file_tag_name: 'frontend',
    page: 1,
    per_page: 25
  }
});

console.log(response.data);

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files/translation_strings')
uri.query = URI.encode_www_form(file_path: 'locales/en.po', file_tag_name: 'frontend', page: 1, q: 'login')

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'

response = http.request(request)
puts response.body

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}

params = {
    'file_path': 'locales/en.po',
    'file_tag_name': 'frontend',
    'page': 1,
    'q': 'login'
}

response = requests.get('https://app.ptc.wpml.org/api/v1/source_files/translation_strings',
                        headers=headers, params=params)
print(response.json())

<?php
$params = http_build_query([
    'file_path' => 'locales/en.po',
    'file_tag_name' => 'frontend',
    'page' => 1,
    'q' => 'login'
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://app.ptc.wpml.org/api/v1/source_files/translation_strings?{$params}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

print_r(json_decode($response, true));
?>

import okhttp3.*;

OkHttpClient client = new OkHttpClient();

HttpUrl url = HttpUrl.parse("https://app.ptc.wpml.org/api/v1/source_files/translation_strings")
    .newBuilder()
    .addQueryParameter("file_path", "locales/en.po")
    .addQueryParameter("file_tag_name", "frontend")
    .addQueryParameter("page", "1")
    .addQueryParameter("q", "login")
    .build();

Request request = new Request.Builder()
    .url(url)
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://app.ptc.wpml.org/api/v1/source_files/translation_strings", nil)

    q := req.URL.Query()
    q.Add("file_path", "locales/en.po")
    q.Add("file_tag_name", "frontend")
    q.Add("page", "1")
    q.Add("q", "login")
    req.URL.RawQuery = q.Encode()

    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var response = await client.GetAsync("https://app.ptc.wpml.org/api/v1/source_files/translation_strings?file_path=locales/en.po&file_tag_name=frontend&page=1&q=login");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

const axios = require('axios');

const response = await axios.get('https://app.ptc.wpml.org/api/v1/source_files/translation_strings', {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' },
  params: {
    file_path: 'locales/en.po',
    file_tag_name: 'frontend',
    page: 1,
    q: 'login'
  }
});

console.log(response.data);

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'
request.set_form_data(
  'file_path' => 'src/locales/en.json',
  'output_file_path' => 'src/locales/{lang}.json'
)

response = http.request(request)
puts response.body

import requests

headers = {'Authorization': 'Bearer YOUR_API_TOKEN'}
data = {
    'file_path': 'src/locales/en.json',
    'output_file_path': 'src/locales/{lang}.json'
}

response = requests.post('https://app.ptc.wpml.org/api/v1/source_files', headers=headers, data=data)
print(response.json())

<?php
$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => 'https://app.ptc.wpml.org/api/v1/source_files',
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => http_build_query([
        'file_path' => 'src/locales/en.json',
        'output_file_path' => 'src/locales/{lang}.json'
    ]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

print_r(json_decode($response, true));
?>

import okhttp3.*;

OkHttpClient client = new OkHttpClient();

RequestBody body = new FormBody.Builder()
    .add("file_path", "src/locales/en.json")
    .add("output_file_path", "src/locales/{lang}.json")
    .build();

Request request = new Request.Builder()
    .url("https://app.ptc.wpml.org/api/v1/source_files")
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .post(body)
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
)

func main() {
    form := url.Values{}
    form.Set("file_path", "src/locales/en.json")
    form.Set("output_file_path", "src/locales/{lang}.json")

    req, _ := http.NewRequest("POST", "https://app.ptc.wpml.org/api/v1/source_files", strings.NewReader(form.Encode()))
    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var form = new FormUrlEncodedContent(new Dictionary<string, string>
{
    { "file_path", "src/locales/en.json" },
    { "output_file_path", "src/locales/{lang}.json" }
});

var response = await client.PostAsync("https://app.ptc.wpml.org/api/v1/source_files", form);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

const axios = require('axios');

const params = new URLSearchParams();
params.append('file_path', 'src/locales/en.json');
params.append('output_file_path', 'src/locales/{lang}.json');

const response = await axios.post('https://app.ptc.wpml.org/api/v1/source_files', params, {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' }
});

console.log(response.data);

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files/process')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'
request.set_form(
  [
    ['file', File.open('updated_translations.json')],
    ['file_path', 'src/locales/en.json'],
    ['file_tag_name', 'frontend'],
    ['callback_url', 'https://your-app.com/webhooks/complete']
  ],
  'multipart/form-data'
)

response = http.request(request)
puts response.body

import requests

headers = {'Authorization': 'Bearer YOUR_API_TOKEN'}
files = {'file': open('updated_translations.json', 'rb')}
data = {
    'file_path': 'src/locales/en.json',
    'file_tag_name': 'frontend',
    'callback_url': 'https://your-app.com/webhooks/complete'
}

response = requests.put('https://app.ptc.wpml.org/api/v1/source_files/process',
                        headers=headers, files=files, data=data)
print(response.json())

<?php
$post_data = [
    'file' => new CURLFile('updated_translations.json'),
    'file_path' => 'src/locales/en.json',
    'file_tag_name' => 'frontend',
    'callback_url' => 'https://your-app.com/webhooks/complete'
];

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => 'https://app.ptc.wpml.org/api/v1/source_files/process',
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_POSTFIELDS => $post_data,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

print_r(json_decode($response, true));
?>

import okhttp3.*;
import java.io.File;

OkHttpClient client = new OkHttpClient();

MultipartBody body = new MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("file", "updated_translations.json",
        RequestBody.create(new File("updated_translations.json"), MediaType.parse("application/octet-stream")))
    .addFormDataPart("file_path", "src/locales/en.json")
    .addFormDataPart("file_tag_name", "frontend")
    .addFormDataPart("callback_url", "https://your-app.com/webhooks/complete")
    .build();

Request request = new Request.Builder()
    .url("https://app.ptc.wpml.org/api/v1/source_files/process")
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .put(body)
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

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

func main() {
    var buf bytes.Buffer
    w := multipart.NewWriter(&buf)

    file, _ := os.Open("updated_translations.json")
    defer file.Close()
    fw, _ := w.CreateFormFile("file", "updated_translations.json")
    io.Copy(fw, file)

    w.WriteField("file_path", "src/locales/en.json")
    w.WriteField("file_tag_name", "frontend")
    w.WriteField("callback_url", "https://your-app.com/webhooks/complete")
    w.Close()

    req, _ := http.NewRequest("PUT", "https://app.ptc.wpml.org/api/v1/source_files/process", &buf)
    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")
    req.Header.Add("Content-Type", w.FormDataContentType())

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var form = new MultipartFormDataContent();
form.Add(new StreamContent(File.OpenRead("updated_translations.json")), "file", "updated_translations.json");
form.Add(new StringContent("src/locales/en.json"), "file_path");
form.Add(new StringContent("frontend"), "file_tag_name");
form.Add(new StringContent("https://your-app.com/webhooks/complete"), "callback_url");

var response = await client.PutAsync("https://app.ptc.wpml.org/api/v1/source_files/process", form);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

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

const form = new FormData();
form.append('file', fs.createReadStream('updated_translations.json'));
form.append('file_path', 'src/locales/en.json');
form.append('file_tag_name', 'frontend');
form.append('callback_url', 'https://your-app.com/webhooks/complete');

const response = await axios.put('https://app.ptc.wpml.org/api/v1/source_files/process', form, {
  headers: {
    ...form.getHeaders(),
    'Authorization': 'Bearer YOUR_API_TOKEN'
  }
});

console.log(response.data);

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files/translation_status')
uri.query = URI.encode_www_form(file_path: 'locales/en.po', file_tag_name: 'frontend')

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'

response = http.request(request)
require 'json'
data = JSON.parse(response.body)
puts "Translation #{data['translation_status']['completeness']}% complete"

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}

params = {
    'file_path': 'locales/en.po',
    'file_tag_name': 'frontend'
}

response = requests.get('https://app.ptc.wpml.org/api/v1/source_files/translation_status',
                        headers=headers, params=params)
data = response.json()
print(f"Translation {data['translation_status']['completeness']}% complete")

<?php
$params = http_build_query([
    'file_path' => 'locales/en.po',
    'file_tag_name' => 'frontend'
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://app.ptc.wpml.org/api/v1/source_files/translation_status?{$params}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

$data = json_decode($response, true);
echo "Translation " . $data['translation_status']['completeness'] . "% complete";
?>

import okhttp3.*;

OkHttpClient client = new OkHttpClient();

HttpUrl url = HttpUrl.parse("https://app.ptc.wpml.org/api/v1/source_files/translation_status")
    .newBuilder()
    .addQueryParameter("file_path", "locales/en.po")
    .addQueryParameter("file_tag_name", "frontend")
    .build();

Request request = new Request.Builder()
    .url(url)
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://app.ptc.wpml.org/api/v1/source_files/translation_status", nil)

    q := req.URL.Query()
    q.Add("file_path", "locales/en.po")
    q.Add("file_tag_name", "frontend")
    req.URL.RawQuery = q.Encode()

    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var response = await client.GetAsync("https://app.ptc.wpml.org/api/v1/source_files/translation_status?file_path=locales/en.po&file_tag_name=frontend");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

const axios = require('axios');

const response = await axios.get('https://app.ptc.wpml.org/api/v1/source_files/translation_status', {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' },
  params: {
    file_path: 'locales/en.po',
    file_tag_name: 'frontend'
  }
});

console.log(`Translation ${response.data.translation_status.completeness}% complete`);

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files/download_translations')
uri.query = URI.encode_www_form(file_path: 'locales/en.po', file_tag_name: 'frontend')

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'

response = http.request(request)
if response.code == '200'
  File.binwrite('translations.zip', response.body)
  puts 'Translations downloaded successfully'
elsif response.code == '202'
  puts 'Translations are still processing — retry after the Retry-After interval'
elsif response.code == '404'
  puts 'No translations are available for this source file yet'
end

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_TOKEN'
}

params = {
    'file_path': 'locales/en.po',
    'file_tag_name': 'frontend'
}

response = requests.get('https://app.ptc.wpml.org/api/v1/source_files/download_translations',
                        headers=headers, params=params)
if response.status_code == 200:
    with open('translations.zip', 'wb') as f:
        f.write(response.content)
    print('Translations downloaded successfully')
elif response.status_code == 202:
    print('Translations are still processing — retry after the Retry-After interval')
elif response.status_code == 404:
    print('No translations are available for this source file yet')

<?php
$params = http_build_query([
    'file_path' => 'locales/en.po',
    'file_tag_name' => 'frontend'
]);

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => "https://app.ptc.wpml.org/api/v1/source_files/download_translations?{$params}",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

if ($httpCode === 200) {
    file_put_contents('translations.zip', $response);
    echo 'Translations downloaded successfully';
} elseif ($httpCode === 202) {
    echo 'Translations are still processing — retry after the Retry-After interval';
} elseif ($httpCode === 404) {
    echo 'No translations are available for this source file yet';
}
?>

import okhttp3.*;
import java.nio.file.*;

OkHttpClient client = new OkHttpClient();

HttpUrl url = HttpUrl.parse("https://app.ptc.wpml.org/api/v1/source_files/download_translations")
    .newBuilder()
    .addQueryParameter("file_path", "locales/en.po")
    .addQueryParameter("file_tag_name", "frontend")
    .build();

Request request = new Request.Builder()
    .url(url)
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .build();

Response response = client.newCall(request).execute();
if (response.code() == 200) {
    Files.write(Paths.get("translations.zip"), response.body().bytes());
    System.out.println("Translations downloaded successfully");
} else if (response.code() == 202) {
    System.out.println("Translations are still processing — retry after the Retry-After interval");
} else if (response.code() == 404) {
    System.out.println("No translations are available for this source file yet");
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    req, _ := http.NewRequest("GET", "https://app.ptc.wpml.org/api/v1/source_files/download_translations", nil)

    q := req.URL.Query()
    q.Add("file_path", "locales/en.po")
    q.Add("file_tag_name", "frontend")
    req.URL.RawQuery = q.Encode()

    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    if resp.StatusCode == 200 {
        body, _ := io.ReadAll(resp.Body)
        os.WriteFile("translations.zip", body, 0644)
        fmt.Println("Translations downloaded successfully")
    } else if resp.StatusCode == 202 {
        fmt.Println("Translations are still processing — retry after the Retry-After interval")
    } else if resp.StatusCode == 404 {
        fmt.Println("No translations are available for this source file yet")
    }
}

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

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var response = await client.GetAsync("https://app.ptc.wpml.org/api/v1/source_files/download_translations?file_path=locales/en.po&file_tag_name=frontend");
if ((int)response.StatusCode == 200) {
    var bytes = await response.Content.ReadAsByteArrayAsync();
    File.WriteAllBytes("translations.zip", bytes);
    Console.WriteLine("Translations downloaded successfully");
} else if ((int)response.StatusCode == 202) {
    Console.WriteLine("Translations are still processing — retry after the Retry-After interval");
} else if ((int)response.StatusCode == 404) {
    Console.WriteLine("No translations are available for this source file yet");
}

const axios = require('axios');
const fs = require('fs');

const response = await axios.get('https://app.ptc.wpml.org/api/v1/source_files/download_translations', {
  headers: { 'Authorization': 'Bearer YOUR_API_TOKEN' },
  responseType: 'stream',
  validateStatus: (s) => s === 200 || s === 202 || s === 404
});

if (response.status === 200) {
  response.data.pipe(fs.createWriteStream('translations.zip'));
  console.log('Translations downloaded successfully');
} else if (response.status === 202) {
  console.log('Translations are still processing — retry after the Retry-After interval');
} else if (response.status === 404) {
  console.log('No translations are available for this source file yet');
}

require 'net/http'
require 'uri'

uri = URI('https://app.ptc.wpml.org/api/v1/source_files/bulk')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN'
request.set_form(
  [
    ['zip_file', File.open('source-files.zip')],
    ['file_tag_name', 'backend'],
    ['callback_url', 'https://your-app.com/webhooks/complete']
  ],
  'multipart/form-data'
)

response = http.request(request)
puts response.body

import requests

headers = {'Authorization': 'Bearer YOUR_API_TOKEN'}
files = {'zip_file': open('source-files.zip', 'rb')}
data = {
    'file_tag_name': 'backend',
    'callback_url': 'https://your-app.com/webhooks/complete'
}

response = requests.post('https://app.ptc.wpml.org/api/v1/source_files/bulk',
                        headers=headers, files=files, data=data)
print(response.json())

<?php
$post_data = [
    'zip_file' => new CURLFile('source-files.zip'),
    'file_tag_name' => 'backend',
    'callback_url' => 'https://your-app.com/webhooks/complete'
];

$curl = curl_init();
curl_setopt_array($curl, [
    CURLOPT_URL => 'https://app.ptc.wpml.org/api/v1/source_files/bulk',
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => $post_data,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_TOKEN'
    ],
]);

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

print_r(json_decode($response, true));
?>

import okhttp3.*;
import java.io.File;

OkHttpClient client = new OkHttpClient();

MultipartBody body = new MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("zip_file", "source-files.zip",
        RequestBody.create(new File("source-files.zip"), MediaType.parse("application/octet-stream")))
    .addFormDataPart("file_tag_name", "backend")
    .addFormDataPart("callback_url", "https://your-app.com/webhooks/complete")
    .build();

Request request = new Request.Builder()
    .url("https://app.ptc.wpml.org/api/v1/source_files/bulk")
    .addHeader("Authorization", "Bearer YOUR_API_TOKEN")
    .post(body)
    .build();

Response response = client.newCall(request).execute();
System.out.println(response.body().string());

package main

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

func main() {
    var buf bytes.Buffer
    w := multipart.NewWriter(&buf)

    file, _ := os.Open("source-files.zip")
    defer file.Close()
    fw, _ := w.CreateFormFile("zip_file", "source-files.zip")
    io.Copy(fw, file)

    w.WriteField("file_tag_name", "backend")
    w.WriteField("callback_url", "https://your-app.com/webhooks/complete")
    w.Close()

    req, _ := http.NewRequest("POST", "https://app.ptc.wpml.org/api/v1/source_files/bulk", &buf)
    req.Header.Add("Authorization", "Bearer YOUR_API_TOKEN")
    req.Header.Add("Content-Type", w.FormDataContentType())

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

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

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_API_TOKEN");

var form = new MultipartFormDataContent();
form.Add(new StreamContent(File.OpenRead("source-files.zip")), "zip_file", "source-files.zip");
form.Add(new StringContent("backend"), "file_tag_name");
form.Add(new StringContent("https://your-app.com/webhooks/complete"), "callback_url");

var response = await client.PostAsync("https://app.ptc.wpml.org/api/v1/source_files/bulk", form);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

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

const form = new FormData();
form.append('zip_file', fs.createReadStream('source-files.zip'));
form.append('file_tag_name', 'backend');
form.append('callback_url', 'https://your-app.com/webhooks/complete');

const response = await axios.post('https://app.ptc.wpml.org/api/v1/source_files/bulk', form, {
  headers: {
    ...form.getHeaders(),
    'Authorization': 'Bearer YOUR_API_TOKEN'
  }
});

console.log(response.data);