Doc Converter Pro - REST API Documentation for Developers

Uses the native fetch API. Ensure you handle errors appropriately in production.

const apiURL = 'https://api.docconverter.pro';

async function fetchTokenData() {
  const body = new URLSearchParams({
    grant_type: 'password',
    username: 'your@email.com',
    password: 'your_password',
  });

  const response = await fetch(apiURL + '/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: body,
  });

  if (!response.ok) {
    let errorData;
    try {
      errorData = await response.json();
    } catch (e) {
      errorData = { message: response.statusText };
    }
    throw new Error(`HTTP error ${response.status}: ${errorData.error_description || errorData.message || 'Failed to fetch token'}`);
  }

  const tokenData = await response.json();
  return tokenData;
}

// Example usage
async function main() {
  try {
    const tokenData = await fetchTokenData();
    console.log('Access Token:', tokenData.access_token);
    // Store and use tokenData.access_token
  } catch (error) {
    console.error('Error fetching token:', error.message);
  }
}

main();
                

Requires the requests library (pip install requests).

import requests

api_url = 'https://api.docconverter.pro/token'
username = 'your@email.com'  # Replace with your email
password = 'your_password'    # Replace with your password

payload = {
    'grant_type': 'password',
    'username': username,
    'password': password
}

headers = {
    'Content-Type': 'application/x-www-form-urlencoded'
}

try:
    response = requests.post(api_url, data=payload, headers=headers)
    response.raise_for_status()  # Raises an HTTPError for bad responses
    token_data = response.json()
    access_token = token_data.get('access_token')
    print(f"Access Token: {access_token}")
except requests.exceptions.HTTPError as errh:
    print(f"Http Error: {errh}")
    # print(f"Response content: {response.text}") # For debugging
except requests.exceptions.RequestException as err:
    print(f"Request Error: {err}")
                

Uses the cURL extension (usually enabled by default).

<?php

$apiUrl = 'https://api.docconverter.pro/token';
$username = 'your@email.com'; // Replace with your email
$password = 'your_password';   // Replace with your password

$postData = http_build_query([
    'grant_type' => 'password',
    'username'   => $username,
    'password'   => $password,
]);

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $apiUrl);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/x-www-form-urlencoded',
]);

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

if (curl_errno($ch)) {
    echo 'cURL Error: ' . curl_error($ch);
} else {
    if ($httpCode == 200) {
        $tokenData = json_decode($response, true);
        if (isset($tokenData['access_token'])) {
            echo "Access Token: " . $tokenData['access_token'] . "\n";
        } else {
            echo "Error: Could not parse token.\nResponse: " . $response . "\n";
        }
    } else {
        echo "HTTP Error: " . $httpCode . "\nResponse: " . $response . "\n";
    }
}

curl_close($ch);

?>
                

Uses HttpClient and System.Text.Json (for .NET Core 3.0+ / .NET 5+). For older versions, consider Newtonsoft.Json.

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

public class TokenFetcher
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task GetAccessTokenAsync()
    {
        var apiUrl = "https://api.docconverter.pro/token";
        var username = "your@email.com";
        var password = "your_password";

        var values = new Dictionary
        {
            { "grant_type", "password" },
            { "username", username },
            { "password", password }
        };
        var content = new FormUrlEncodedContent(values);

        try
        {
            HttpResponseMessage response = await client.PostAsync(apiUrl, content);
            response.EnsureSuccessStatusCode(); 
            string responseBody = await response.Content.ReadAsStringAsync();
            
            using (JsonDocument doc = JsonDocument.Parse(responseBody))
            {
                JsonElement root = doc.RootElement;
                if (root.TryGetProperty("access_token", out JsonElement accessTokenElement))
                {
                    return accessTokenElement.GetString();
                }
            }
            return null;
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request error: {e.Message}");
            // Consider logging e.InnerException or response content if available
            return null;
        }
    }

    public static async Task Main(string[] args)
    {
        string accessToken = await GetAccessTokenAsync();
        if (!string.IsNullOrEmpty(accessToken))
        {
            Console.WriteLine($"Access Token: {accessToken}");
        }
        else
        {
            Console.WriteLine("Failed to retrieve access token.");
        }
    }
}
                

Uses built-in HttpURLConnection. For production, consider libraries like OkHttp, Apache HttpClient, or Spring RestTemplate. For JSON parsing, libraries like Jackson, Gson, or org.json are recommended (example uses org.json in comments).

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.StringJoiner;
// import org.json.JSONObject; // Add dependency: e.g., org.json:json:20231013

public class TokenFetcher {
    public static void main(String[] args) {
        String apiUrl = "https://api.docconverter.pro/token";
        String username = "your@email.com";
        String password = "your_password";

        try {
            URL url = new URL(apiUrl);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setRequestMethod("POST");
            con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            con.setDoOutput(true);

            Map parameters = new HashMap<>();
            parameters.put("grant_type", "password");
            parameters.put("username", username);
            parameters.put("password", password);

            StringJoiner sj = new StringJoiner("&");
            for (Map.Entry entry : parameters.entrySet()) {
                sj.add(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8.name()) + "=" +
                       URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8.name()));
            }
            byte[] postDataBytes = sj.toString().getBytes(StandardCharsets.UTF_8);

            try (OutputStream os = con.getOutputStream()) {
                os.write(postDataBytes);
            }

            int responseCode = con.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
                StringBuilder response = new StringBuilder();
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println("Raw Response: " + response.toString());
                // JSONObject tokenData = new JSONObject(response.toString());
                // String accessToken = tokenData.getString("access_token");
                // System.out.println("Access Token: " + accessToken);
            } else {
                System.out.println("POST request failed. Response: " + con.getResponseMessage());
                 try(BufferedReader errorReader = new BufferedReader(new InputStreamReader(con.getErrorStream()))){
                    StringBuilder errorResponse = new StringBuilder(); String errorLine;
                    while((errorLine = errorReader.readLine()) != null) { errorResponse.append(errorLine); }
                    System.out.println("Error Details: " + errorResponse.toString());
                } catch (Exception ex) {/* no error stream */}
            }
            con.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}