Bijoy ↔ Unicode Conversion API for Developers

Need to integrate Bengali text conversion into your application? The Bijoy ↔ Unicode Conversion API provides a simple, free REST interface for converting text between Bijoy encoding and Unicode Bengali - in both directions.

Whether you're building a CMS, content migration tool, mobile app, or any application that handles Bengali text, this API makes it easy to convert legacy Bijoy content to modern Unicode, or generate Bijoy-encoded text for legacy printing systems.

1. Quick Start

Get started in seconds. The API requires no authentication - just make HTTP POST requests.

# Bijoy to Unicode
curl -X POST https://bijoy.converteraz.com/api/convert/bijoy-to-unicode \
  -H "Content-Type: application/json" \
  -d '{"text": "Avwg evsjvq Mvb MvB"}'

# Unicode to Bijoy
curl -X POST https://bijoy.converteraz.com/api/convert/unicode-to-bijoy \
  -H "Content-Type: application/json" \
  -d '{"text": "আমি বাংলায় গান গাই"}'

2. API Endpoints

{
  "text": "Avwg evsjvq Mvb MvB"
}

{
  "success": true,
  "input": "Avwg evsjvq Mvb MvB",
  "output": "আমি বাংলায় গান গাই",
  "inputLength": 18,
  "outputLength": 18
}

{
  "text": "আমি বাংলায় গান গাই"
}

{
  "success": true,
  "input": "আমি বাংলায় গান গাই",
  "output": "Avwg evsjvq Mvb MvB",
  "inputLength": 18,
  "outputLength": 18
}

3. Code Examples

Here are ready-to-use code examples in popular programming languages. Each example shows both conversion directions.

// Bijoy to Unicode
async function bijoyToUnicode(text) {
  const response = await fetch('https://bijoy.converteraz.com/api/convert/bijoy-to-unicode', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text })
  });
  const data = await response.json();
  return data.output;
}

// Unicode to Bijoy
async function unicodeToBijoy(text) {
  const response = await fetch('https://bijoy.converteraz.com/api/convert/unicode-to-bijoy', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text })
  });
  const data = await response.json();
  return data.output;
}

// Usage
const unicode = await bijoyToUnicode('Avwg evsjvq Mvb MvB');
console.log(unicode); // আমি বাংলায় গান গাই

const bijoy = await unicodeToBijoy('আমি বাংলায় গান গাই');
console.log(bijoy); // Avwg evsjvq Mvb MvB

const BASE_URL = 'https://bijoy.converteraz.com';

async function convertText(text, direction) {
  const endpoint = direction === 'bijoy-to-unicode'
    ? '/api/convert/bijoy-to-unicode'
    : '/api/convert/unicode-to-bijoy';

  const response = await fetch(BASE_URL + endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text })
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data = await response.json();
  return data.output;
}

// Usage
const unicode = await convertText('Avwg evsjvq Mvb MvB', 'bijoy-to-unicode');
const bijoy = await convertText('আমি বাংলায় গান গাই', 'unicode-to-bijoy');

import requests

BASE_URL = 'https://bijoy.converteraz.com'

def bijoy_to_unicode(text):
    response = requests.post(
        f'{BASE_URL}/api/convert/bijoy-to-unicode',
        json={'text': text}
    )
    response.raise_for_status()
    return response.json()['output']

def unicode_to_bijoy(text):
    response = requests.post(
        f'{BASE_URL}/api/convert/unicode-to-bijoy',
        json={'text': text}
    )
    response.raise_for_status()
    return response.json()['output']

# Usage
unicode_text = bijoy_to_unicode('Avwg evsjvq Mvb MvB')
print(unicode_text)  # আমি বাংলায় গান গাই

bijoy_text = unicode_to_bijoy('আমি বাংলায় গান গাই')
print(bijoy_text)  # Avwg evsjvq Mvb MvB

<?php

function convertBengaliText($text, $direction = 'bijoy-to-unicode') {
    $baseUrl = 'https://bijoy.converteraz.com';
    $endpoint = $direction === 'bijoy-to-unicode'
        ? '/api/convert/bijoy-to-unicode'
        : '/api/convert/unicode-to-bijoy';

    $ch = curl_init($baseUrl . $endpoint);
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode(['text' => $text]),
        CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true
    ]);

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

    if ($httpCode !== 200) {
        throw new Exception("API error: $httpCode");
    }

    $data = json_decode($response, true);
    return $data['output'];
}

// Usage
$unicode = convertBengaliText('Avwg evsjvq Mvb MvB', 'bijoy-to-unicode');
echo $unicode; // আমি বাংলায় গান গাই

$bijoy = convertBengaliText('আমি বাংলায় গান গাই', 'unicode-to-bijoy');
echo $bijoy; // Avwg evsjvq Mvb MvB

?>

# Bijoy to Unicode
curl -X POST https://bijoy.converteraz.com/api/convert/bijoy-to-unicode \
  -H "Content-Type: application/json" \
  -d '{"text": "Avwg evsjvq Mvb MvB"}'

# Response: {"success":true,"input":"Avwg evsjvq Mvb MvB","output":"আমি বাংলায় গান গাই",...}

# Unicode to Bijoy
curl -X POST https://bijoy.converteraz.com/api/convert/unicode-to-bijoy \
  -H "Content-Type: application/json" \
  -d '{"text": "আমি বাংলায় গান গাই"}'

# Response: {"success":true,"input":"আমি বাংলায় গান গাই","output":"Avwg evsjvq Mvb MvB",...}

Header: X-App-Id: com.yourcompany.yourapp

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class BijoyConverter {
    private val client = OkHttpClient()
    private val baseUrl = "https://bijoy.converteraz.com"
    private val appId = "com.yourcompany.yourapp" // Your app identifier

    suspend fun bijoyToUnicode(text: String): String = withContext(Dispatchers.IO) {
        convert(text, "/api/convert/bijoy-to-unicode")
    }

    suspend fun unicodeToBijoy(text: String): String = withContext(Dispatchers.IO) {
        convert(text, "/api/convert/unicode-to-bijoy")
    }

    private fun convert(text: String, endpoint: String): String {
        val json = JSONObject().put("text", text).toString()
        val body = json.toRequestBody("application/json".toMediaType())

        val request = Request.Builder()
            .url(baseUrl + endpoint)
            .addHeader("Content-Type", "application/json")
            .addHeader("X-App-Id", appId) // Identify your app
            .post(body)
            .build()

        client.newCall(request).execute().use { response ->
            if (!response.isSuccessful) throw Exception("API error: ${response.code}")
            val result = JSONObject(response.body?.string() ?: "")
            return result.getString("output")
        }
    }
}

// Usage in ViewModel or Coroutine scope
val converter = BijoyConverter()
val unicode = converter.bijoyToUnicode("Avwg evsjvq Mvb MvB")
// Result: আমি বাংলায় গান গাই

// ApiService.java
public interface BijoyApiService {
    @POST("/api/convert/bijoy-to-unicode")
    Call<ConversionResponse> bijoyToUnicode(
        @Header("X-App-Id") String appId,
        @Body ConversionRequest request
    );

    @POST("/api/convert/unicode-to-bijoy")
    Call<ConversionResponse> unicodeToBijoy(
        @Header("X-App-Id") String appId,
        @Body ConversionRequest request
    );
}

// ConversionRequest.java
public class ConversionRequest {
    public String text;
    public ConversionRequest(String text) { this.text = text; }
}

// ConversionResponse.java
public class ConversionResponse {
    public boolean success;
    public String input;
    public String output;
}

// Usage
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://bijoy.converteraz.com")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

BijoyApiService api = retrofit.create(BijoyApiService.class);
String appId = "com.yourcompany.yourapp";

api.bijoyToUnicode(appId, new ConversionRequest("Avwg evsjvq Mvb MvB"))
    .enqueue(new Callback<ConversionResponse>() {
        @Override
        public void onResponse(Call<ConversionResponse> call, Response<ConversionResponse> response) {
            if (response.isSuccessful()) {
                String unicode = response.body().output;
                // Result: আমি বাংলায় গান গাই
            }
        }
        @Override
        public void onFailure(Call<ConversionResponse> call, Throwable t) {
            // Handle error
        }
    });

import Foundation

class BijoyConverter {
    private let baseURL = "https://bijoy.converteraz.com"
    private let appId = "com.yourcompany.yourapp" // Your app identifier

    struct ConversionResponse: Codable {
        let success: Bool
        let input: String
        let output: String
    }

    func bijoyToUnicode(_ text: String) async throws -> String {
        return try await convert(text, endpoint: "/api/convert/bijoy-to-unicode")
    }

    func unicodeToBijoy(_ text: String) async throws -> String {
        return try await convert(text, endpoint: "/api/convert/unicode-to-bijoy")
    }

    private func convert(_ text: String, endpoint: String) async throws -> String {
        guard let url = URL(string: baseURL + endpoint) else {
            throw URLError(.badURL)
        }

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(appId, forHTTPHeaderField: "X-App-Id") // Identify your app

        let body = ["text": text]
        request.httpBody = try JSONSerialization.data(withJSONObject: body)

        let (data, response) = try await URLSession.shared.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }

        let result = try JSONDecoder().decode(ConversionResponse.self, from: data)
        return result.output
    }
}

// Usage
let converter = BijoyConverter()

Task {
    do {
        let unicode = try await converter.bijoyToUnicode("Avwg evsjvq Mvb MvB")
        print(unicode) // আমি বাংলায় গান গাই

        let bijoy = try await converter.unicodeToBijoy("আমি বাংলায় গান গাই")
        print(bijoy) // Avwg evsjvq Mvb MvB
    } catch {
        print("Error: \(error)")
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

class BijoyConverter {
  static const String _baseUrl = 'https://bijoy.converteraz.com';
  static const String _appId = 'com.yourcompany.yourapp'; // Your app identifier

  Future<String> bijoyToUnicode(String text) async {
    return await _convert(text, '/api/convert/bijoy-to-unicode');
  }

  Future<String> unicodeToBijoy(String text) async {
    return await _convert(text, '/api/convert/unicode-to-bijoy');
  }

  Future<String> _convert(String text, String endpoint) async {
    final response = await http.post(
      Uri.parse(_baseUrl + endpoint),
      headers: {
        'Content-Type': 'application/json',
        'X-App-Id': _appId, // Identify your app
      },
      body: jsonEncode({'text': text}),
    );

    if (response.statusCode != 200) {
      throw Exception('API error: ${response.statusCode}');
    }

    final data = jsonDecode(response.body);
    return data['output'] as String;
  }
}

// Usage
final converter = BijoyConverter();

void convertText() async {
  try {
    final unicode = await converter.bijoyToUnicode('Avwg evsjvq Mvb MvB');
    print(unicode); // আমি বাংলায় গান গাই

    final bijoy = await converter.unicodeToBijoy('আমি বাংলায় গান গাই');
    print(bijoy); // Avwg evsjvq Mvb MvB
  } catch (e) {
    print('Error: $e');
  }
}

// bijoyConverter.ts
const BASE_URL = 'https://bijoy.converteraz.com';
const APP_ID = 'com.yourcompany.yourapp'; // Your app identifier

interface ConversionResponse {
  success: boolean;
  input: string;
  output: string;
}

export async function bijoyToUnicode(text: string): Promise<string> {
  return convert(text, '/api/convert/bijoy-to-unicode');
}

export async function unicodeToBijoy(text: string): Promise<string> {
  return convert(text, '/api/convert/unicode-to-bijoy');
}

async function convert(text: string, endpoint: string): Promise<string> {
  const response = await fetch(BASE_URL + endpoint, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-App-Id': APP_ID, // Identify your app
    },
    body: JSON.stringify({ text }),
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data: ConversionResponse = await response.json();
  return data.output;
}

// Usage in React Native component
import { bijoyToUnicode, unicodeToBijoy } from './bijoyConverter';

const MyComponent = () => {
  const handleConvert = async () => {
    try {
      const unicode = await bijoyToUnicode('Avwg evsjvq Mvb MvB');
      console.log(unicode); // আমি বাংলায় গান গাই

      const bijoy = await unicodeToBijoy('আমি বাংলায় গান গাই');
      console.log(bijoy); // Avwg evsjvq Mvb MvB
    } catch (error) {
      console.error('Conversion error:', error);
    }
  };

  return <Button onPress={handleConvert} title="Convert" />;
};

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

public class BijoyConverter
{
    private readonly HttpClient _client;
    private const string BaseUrl = "https://bijoy.converteraz.com";
    private const string AppId = "com.yourcompany.yourapp"; // Your app identifier

    public BijoyConverter()
    {
        _client = new HttpClient();
        _client.DefaultRequestHeaders.Add("X-App-Id", AppId);
    }

    public async Task<string> BijoyToUnicodeAsync(string text)
    {
        return await ConvertAsync(text, "/api/convert/bijoy-to-unicode");
    }

    public async Task<string> UnicodeToBijoyAsync(string text)
    {
        return await ConvertAsync(text, "/api/convert/unicode-to-bijoy");
    }

    private async Task<string> ConvertAsync(string text, string endpoint)
    {
        var content = new StringContent(
            JsonSerializer.Serialize(new { text }),
            Encoding.UTF8,
            "application/json"
        );

        var response = await _client.PostAsync(BaseUrl + endpoint, content);
        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        var result = JsonSerializer.Deserialize<ConversionResponse>(json);
        return result?.Output ?? "";
    }
}

public class ConversionResponse
{
    public bool Success { get; set; }
    public string Input { get; set; }
    public string Output { get; set; }
}

// Usage
var converter = new BijoyConverter();
var unicode = await converter.BijoyToUnicodeAsync("Avwg evsjvq Mvb MvB");
// Result: আমি বাংলায় গান গাই

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

const (
    baseURL = "https://bijoy.converteraz.com"
    appID   = "com.yourcompany.yourapp" // Your app identifier
)

type ConversionRequest struct {
    Text string `json:"text"`
}

type ConversionResponse struct {
    Success bool   `json:"success"`
    Input   string `json:"input"`
    Output  string `json:"output"`
}

func BijoyToUnicode(text string) (string, error) {
    return convert(text, "/api/convert/bijoy-to-unicode")
}

func UnicodeToBijoy(text string) (string, error) {
    return convert(text, "/api/convert/unicode-to-bijoy")
}

func convert(text, endpoint string) (string, error) {
    reqBody, _ := json.Marshal(ConversionRequest{Text: text})

    req, _ := http.NewRequest("POST", baseURL+endpoint, bytes.NewBuffer(reqBody))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-App-Id", appID) // Identify your app

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result ConversionResponse
    json.Unmarshal(body, &result)

    return result.Output, nil
}

func main() {
    unicode, _ := BijoyToUnicode("Avwg evsjvq Mvb MvB")
    fmt.Println(unicode) // আমি বাংলায় গান গাই
}

require 'net/http'
require 'json'
require 'uri'

class BijoyConverter
  BASE_URL = 'https://bijoy.converteraz.com'
  APP_ID = 'com.yourcompany.yourapp' # Your app identifier

  def bijoy_to_unicode(text)
    convert(text, '/api/convert/bijoy-to-unicode')
  end

  def unicode_to_bijoy(text)
    convert(text, '/api/convert/unicode-to-bijoy')
  end

  private

  def convert(text, endpoint)
    uri = URI.parse(BASE_URL + endpoint)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri.path)
    request['Content-Type'] = 'application/json'
    request['X-App-Id'] = APP_ID # Identify your app
    request.body = { text: text }.to_json

    response = http.request(request)
    result = JSON.parse(response.body)
    result['output']
  end
end

# Usage
converter = BijoyConverter.new
unicode = converter.bijoy_to_unicode('Avwg evsjvq Mvb MvB')
puts unicode # আমি বাংলায় গান গাই

4. Rate Limits & Error Handling

Rate Limits

Rate Limit Headers

The API includes rate limit information in response headers:

Error Responses

{
  "success": false,
  "error": "Text is required"
}

5. Use Cases

6. Frequently Asked Questions

7. Attribution Requirements

This API is free to use, but we kindly request that you provide attribution when using it in your applications. This helps us continue to maintain and improve the service for everyone.

<a href="https://bijoy.converteraz.com">
  Powered by Bijoy Unicode Converter API
</a>