Documentation

import requests

headers = {"X-Api-Key": "fc_your_api_key_here"}

response = requests.get(
    "https://filechanger.io/api/formats",
    headers=headers,
)

print(response.json())

const response = await fetch("https://filechanger.io/api/formats", {
  headers: {
    "X-Api-Key": "fc_your_api_key_here",
  },
});

const data = await response.json();
console.log(data);

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://filechanger.io/api/formats"))
    .header("X-Api-Key", "fc_your_api_key_here")
    .GET()
    .build();

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

System.out.println(response.body());

import Network.HTTP.Simple

main :: IO ()
main = do
  let request = setRequestHeader "X-Api-Key" ["fc_your_api_key_here"]
              $ "GET https://filechanger.io/api/formats"

  response <- httpBS request
  print (getResponseBody response)

import requests

with open("document.md", "rb") as f:
    response = requests.post(
        "https://filechanger.io/api/jobs",
        headers={"X-Api-Key": "fc_your_api_key_here"},
        files={"file": f},
        data={"from": "markdown", "to": "docx"},
    )

job = response.json()
print("Job id:", job["job_id"])

const formData = new FormData();
formData.append("file", fileInput.files[0]);
formData.append("from", "markdown");
formData.append("to", "docx");

const response = await fetch("https://filechanger.io/api/jobs", {
  method: "POST",
  headers: { "X-Api-Key": "fc_your_api_key_here" },
  body: formData,
});

const job = await response.json();
console.log("Job id:", job.job_id);

import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;

String boundary = "----FormBoundary" + System.currentTimeMillis();
byte[] fileBytes = java.nio.file.Files.readAllBytes(Path.of("document.md"));

String body = "--" + boundary + "\r\n"
    + "Content-Disposition: form-data; name=\"file\"; filename=\"document.md\"\r\n"
    + "Content-Type: text/markdown\r\n\r\n"
    + new String(fileBytes) + "\r\n"
    + "--" + boundary + "\r\nContent-Disposition: form-data; name=\"from\"\r\n\r\nmarkdown\r\n"
    + "--" + boundary + "\r\nContent-Disposition: form-data; name=\"to\"\r\n\r\ndocx\r\n"
    + "--" + boundary + "--";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://filechanger.io/api/jobs"))
    .header("X-Api-Key", "fc_your_api_key_here")
    .header("Content-Type", "multipart/form-data; boundary=" + boundary)
    .POST(BodyPublishers.ofString(body))
    .build();

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

System.out.println(response.body());

import Network.HTTP.Client
import Network.HTTP.Client.MultipartFormData

main :: IO ()
main = do
  manager <- newManager defaultManagerSettings
  initialReq <- parseRequest "POST https://filechanger.io/api/jobs"
  let req = initialReq
        { requestHeaders = [("X-Api-Key", "fc_your_api_key_here")] }
  request <- formDataBody
    [ partFileSource "file" "document.md"
    , partBS "from" "markdown"
    , partBS "to" "docx"
    ] req

  response <- httpLbs request manager
  print (responseBody response)

import time
import requests

headers = {"X-Api-Key": "fc_your_api_key_here"}
job_id = "42"

while True:
    status = requests.get(
        f"https://filechanger.io/api/jobs/{job_id}", headers=headers
    ).json()
    if status["status"] == "done":
        break
    if status["status"] == "failed":
        raise RuntimeError(status.get("error", "conversion failed"))
    time.sleep(0.5)

output = requests.get(
    f"https://filechanger.io/api/jobs/{job_id}/output", headers=headers
)
with open("document.docx", "wb") as out:
    out.write(output.content)

const headers = { "X-Api-Key": "fc_your_api_key_here" };
const jobId = "42";

let status;
do {
  await new Promise((r) => setTimeout(r, 500));
  const res = await fetch("https://filechanger.io/api/jobs/" + jobId, { headers });
  status = await res.json();
  if (status.status === "failed") throw new Error(status.error);
} while (status.status !== "done");

const output = await fetch(
  "https://filechanger.io/api/jobs/" + jobId + "/output", { headers }
);
const blob = await output.blob();
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url;
a.download = "document.docx";
a.click();

import java.net.http.HttpResponse.BodyHandlers;
import java.nio.file.Path;

String jobId = "42";
String statusUrl = "https://filechanger.io/api/jobs/" + jobId;

String status;
do {
    Thread.sleep(500);
    HttpRequest poll = HttpRequest.newBuilder()
        .uri(URI.create(statusUrl))
        .header("X-Api-Key", "fc_your_api_key_here")
        .GET().build();
    status = client.send(poll, BodyHandlers.ofString()).body();
} while (!status.contains("\"status\":\"done\""));

HttpRequest download = HttpRequest.newBuilder()
    .uri(URI.create(statusUrl + "/output"))
    .header("X-Api-Key", "fc_your_api_key_here")
    .GET().build();

HttpResponse<byte[]> response = client.send(
    download, BodyHandlers.ofByteArray());
java.nio.file.Files.write(Path.of("document.docx"), response.body());

import Network.HTTP.Simple
import qualified Data.ByteString.Lazy as BL
import Control.Concurrent (threadDelay)
import qualified Data.ByteString.Char8 as B8

main :: IO ()
main = do
  let jobId = "42"
      key = setRequestHeader "X-Api-Key" ["fc_your_api_key_here"]
      pollUntilDone = do
        resp <- httpBS (key $ "GET https://filechanger.io/api/jobs/" <> jobId)
        if "\"status\":\"done\"" `B8.isInfixOf` getResponseBody resp
          then pure ()
          else threadDelay 500000 >> pollUntilDone
  pollUntilDone
  output <- httpLBS (key $ "GET https://filechanger.io/api/jobs/" <> jobId <> "/output")
  BL.writeFile "document.docx" (getResponseBody output)

import requests

response = requests.get("https://filechanger.io/api/formats")

formats = response.json()
print("Input formats:", formats["input_formats"])
print("Output formats:", formats["output_formats"])

const response = await fetch("https://filechanger.io/api/formats");

const formats = await response.json();
console.log("Input formats:", formats.input_formats);
console.log("Output formats:", formats.output_formats);

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://filechanger.io/api/formats"))
    .GET()
    .build();

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

System.out.println(response.body());

import Network.HTTP.Simple

main :: IO ()
main = do
  let request = "GET https://filechanger.io/api/formats"

  response <- httpBS request
  print (getResponseBody response)