API Documentation

Integrate Singlish to Unicode conversion into your own applications

Introduction

The Singlish Unicode Converter API allows you to convert between Singlish (transliterated Sinhala), Unicode Sinhala, and legacy font formats (FM Abaya and ISI) programmatically. This enables you to add Sinhala text conversion capabilities to your own applications, websites, or services.

This API is free to use for non-commercial purposes with appropriate attribution. For commercial use or high-volume applications, please contact us for details.

API Reference

Endpoint

https://singlish.kdj.lk/api.php

Request Format

Send a POST request with a JSON body containing the following parameters:

Parameter	Type	Required	Description
text	String	Yes	The text to convert
inputType	String	No	Input type: "singlish" (default) or "unicode"
format	String	No	Output format: "unicode" (default), "font" (FM Abaya), or "isi" (ISI font)

Response Format

The API returns a JSON response with the following structure:

{
  "status": "success",
  "result": "converted_text",
  "format": "output_format"
}

In case of an error, the response will be:

{
  "status": "error",
  "message": "Error message"
}

Example Request/Response

// Request
POST /singlish/api.php
Content-Type: application/json

{
  "text": "ayubowan",
  "inputType": "singlish",
  "format": "unicode"
}

// Response
{
  "status": "success",
  "result": "ආයුබෝවන්",
  "format": "unicode"
}

Implementation Examples

JavaScript (Fetch API)

// Using Fetch API
async function convertToUnicode(text) {
  try {
    const response = await fetch('https://singlish.kdj.lk/api.php', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text: text,
        inputType: 'singlish',
        format: 'unicode'
      })
    });
    
    const data = await response.json();
    
    if (data.status === 'success') {
      return data.result;
    } else {
      throw new Error(data.message || 'Conversion failed');
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Example usage
convertToUnicode('ayubowan')
  .then(result => {
    console.log(result); // Outputs: ආයුබෝවන්
  })
  .catch(error => {
    console.error('Error:', error);
  });

JavaScript (jQuery)

// Using jQuery
function convertToUnicode(text) {
  return $.ajax({
    url: 'https://singlish.kdj.lk/api.php',
    type: 'POST',
    contentType: 'application/json',
    data: JSON.stringify({
      text: text,
      inputType: 'singlish',
      format: 'unicode'
    })
  });
}

// Example usage
convertToUnicode('ayubowan')
  .done(function(data) {
    if (data.status === 'success') {
      console.log(data.result); // Outputs: ආයුබෝවන්
    } else {
      console.error('Error:', data.message || 'Conversion failed');
    }
  })
  .fail(function(xhr, status, error) {
    console.error('Request failed:', error);
  });

PHP (cURL)

// Using cURL
function convertToUnicode($text) {
    $url = 'https://singlish.kdj.lk/api.php';
    $data = [
        'text' => $text,
        'inputType' => 'singlish',
        'format' => 'unicode'
    ];
    
    $options = [
        CURLOPT_URL => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode($data),
        CURLOPT_HTTPHEADER => [
            'Content-Type: application/json'
        ]
    ];
    
    $curl = curl_init();
    curl_setopt_array($curl, $options);
    $response = curl_exec($curl);
    $err = curl_error($curl);
    curl_close($curl);
    
    if ($err) {
        throw new Exception('cURL Error: ' . $err);
    }
    
    $result = json_decode($response, true);
    
    if ($result['status'] === 'success') {
        return $result['result'];
    } else {
        throw new Exception($result['message'] ?? 'Conversion failed');
    }
}

// Example usage
try {
    $unicodeText = convertToUnicode('ayubowan');
    echo $unicodeText; // Outputs: ආයුබෝවන්
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

Python (requests)

import requests
import json

def convert_to_unicode(text):
    url = 'https://singlish.kdj.lk/api.php'
    data = {
        'text': text,
        'inputType': 'singlish',
        'format': 'unicode'
    }
    
    headers = {
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.post(url, data=json.dumps(data), headers=headers)
        response.raise_for_status()  # Raise exception for 4XX/5XX status codes
        
        result = response.json()
        
        if result['status'] == 'success':
            return result['result']
        else:
            raise Exception(result.get('message', 'Conversion failed'))
    except requests.exceptions.RequestException as e:
        raise Exception(f'Request error: {str(e)}')
    except json.JSONDecodeError:
        raise Exception('Invalid JSON response')
    except Exception as e:
        raise e

# Example usage
try:
    unicode_text = convert_to_unicode('ayubowan')
    print(unicode_text)  # Outputs: ආයුබෝවන්
except Exception as e:
    print(f'Error: {str(e)}')

Java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import org.json.JSONObject;

public class SinglishConverter {
    private static final String API_URL = "https://singlish.kdj.lk/api.php";
    
    public static String convertToUnicode(String text) throws IOException {
        URL url = new URL(API_URL);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
        conn.setRequestProperty("Accept", "application/json");
        conn.setDoOutput(true);
        
        // Create JSON request body
        JSONObject jsonInput = new JSONObject();
        jsonInput.put("text", text);
        jsonInput.put("inputType", "singlish");
        jsonInput.put("format", "unicode");
        
        // Send request
        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = jsonInput.toString().getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }
        
        // Check response code
        if (conn.getResponseCode() != HttpURLConnection.HTTP_OK) {
            throw new IOException("HTTP error code: " + conn.getResponseCode());
        }
        
        // Read response
        StringBuilder response = new StringBuilder();
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = br.readLine()) != null) {
                response.append(line);
            }
        }
        
        // Parse JSON response
        JSONObject jsonResponse = new JSONObject(response.toString());
        if (jsonResponse.getString("status").equals("success")) {
            return jsonResponse.getString("result");
        } else {
            throw new IOException(jsonResponse.optString("message", "Conversion failed"));
        }
    }
    
    public static void main(String[] args) {
        try {
            String unicodeText = convertToUnicode("ayubowan");
            System.out.println(unicodeText); // Outputs: ආයුබෝවන්
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

C# (.NET)

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

public class SinglishConverter
{
    private static readonly HttpClient client = new HttpClient();
    private const string ApiUrl = "https://singlish.kdj.lk/api.php";
    
    public static async Task<string> ConvertToUnicodeAsync(string text)
    {
        var requestData = new
        {
            text = text,
            inputType = "singlish",
            format = "unicode"
        };
        
        var jsonContent = JsonSerializer.Serialize(requestData);
        var stringContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
        
        HttpResponseMessage response = await client.PostAsync(ApiUrl, stringContent);
        response.EnsureSuccessStatusCode();
        
        string responseBody = await response.Content.ReadAsStringAsync();
        using JsonDocument doc = JsonDocument.Parse(responseBody);
        
        JsonElement root = doc.RootElement;
        string status = root.GetProperty("status").GetString();
        
        if (status == "success")
        {
            return root.GetProperty("result").GetString();
        }
        else
        {
            string errorMessage = "Conversion failed";
            if (root.TryGetProperty("message", out JsonElement messageElement))
            {
                errorMessage = messageElement.GetString();
            }
            throw new Exception(errorMessage);
        }
    }
    
    // Example usage in async method
    public static async Task ExampleUsage()
    {
        try
        {
            string unicodeText = await ConvertToUnicodeAsync("ayubowan");
            Console.WriteLine(unicodeText); // Outputs: ආයුබෝවන්
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Rate Limits and Usage Guidelines

This API is provided for free for non-commercial use with the following limitations:

Maximum 1000 requests per hour per IP address
Maximum text length of 2000 characters per request
Please include proper attribution to KDJ Singlish Converter in your application

For commercial use, higher rate limits, or custom solutions, please contact us.

Support and Contact

Having trouble with the API? Need help with integration? We're here to help!

Email Support

[email protected]