Indonesia Dictionary API

Overview

The Indonesia Dictionary API offers a service for developers to integrate comprehensive English-Indonesian and Indonesian-English dictionary functionalities into various applications. It serves as a resource for retrieving definitions, example sentences, and contextual usage for words in both languages. The API's core products include dedicated endpoints for looking up terms from English to Indonesian and vice-versa, making it suitable for applications requiring bidirectional translation capabilities.

This API is primarily designed for developers building language learning applications, where users might need instant access to word meanings and usage examples. For instance, an application focused on teaching Indonesian vocabulary could utilize the Indonesia Dictionary API documentation to display definitions and example sentences for new words. Similarly, translation services can employ the API to augment their existing linguistic datasets, ensuring accuracy and providing detailed contextual information beyond simple word-for-word translation. Content localization platforms can also benefit by ensuring correct terminology and phrasing when adapting materials for an Indonesian-speaking audience.

The API operates on a RESTful architecture, delivering responses in JSON format. This approach is standard for web services, allowing for straightforward integration across a wide range of programming languages and environments. Developers can send HTTP requests to specific endpoints and receive structured data containing dictionary entries. The design emphasizes ease of use, with clear documentation that includes code examples in several popular languages such as Python, JavaScript, PHP, Ruby, and Go, facilitating a quicker development cycle.

While the Indonesia Dictionary API focuses specifically on the English-Indonesian language pair, its granular data, including definitions, synonyms, and example sentences, provides a more in-depth resource than general machine translation services. This specificity makes it a valuable tool for projects where linguistic precision and detailed lexical information are critical, such as academic tools or specialized content creation. The API's free tier allows for initial development and testing, providing 500 requests per month, which can be sufficient for small-scale projects or proof-of-concept implementations.

Key features

• Bidirectional Dictionary Access: Provides distinct APIs for English-Indonesian and Indonesian-English word lookups, supporting comprehensive translation and definition retrieval in both directions.
• RESTful API with JSON Responses: Utilizes standard HTTP methods and returns data in JSON format, facilitating integration with most modern web and mobile applications.
• Detailed Lexical Data: Each dictionary entry can include definitions, parts of speech, and example sentences to provide contextual understanding.
• Multi-language Code Examples: Documentation includes practical code snippets in Python, JavaScript, PHP, Ruby, and Go, aiding developers in quick implementation.
• Scalable Request Tiers: Offers a free tier for initial development and testing, along with paid plans that scale to accommodate higher request volumes for production applications.
• Focus on Language Learning: Specifically designed to support applications aimed at teaching or learning the Indonesian language, offering detailed linguistic resources.

Pricing

The Indonesia Dictionary API offers a free tier for initial development and testing, alongside paid subscription plans for higher usage volumes. As of 2026-05-28, the pricing structure is as follows:

For more detailed information on pricing tiers and additional features, refer to the official Indonesia Dictionary API pricing page.

Common integrations

• Web Applications: Integrate dictionary lookup functionality into web-based language learning platforms or content management systems using JavaScript frameworks like React, Angular, or Vue.js.
• Mobile Applications: Develop iOS or Android apps that provide on-demand English-Indonesian translations and definitions for users learning the language.
• Chatbots and Virtual Assistants: Enhance conversational AI with the ability to define Indonesian or English words, improving user interaction in language-focused chatbots.
• Content Localization Tools: Incorporate into custom tools for translating and localizing website content, documents, or marketing materials into Indonesian.
• Educational Software: Build interactive learning modules or quizzes that leverage the API for vocabulary building and comprehension checks.

Alternatives

• RapidAPI (various dictionary APIs): A marketplace offering access to a multitude of dictionary APIs, some of which may support Indonesian or a broader range of languages.
• Google Translate API: Provides machine translation for over 100 languages, including Indonesian, though it focuses on translation rather than detailed dictionary definitions.
• Oxford Dictionaries API: Offers access to comprehensive lexical data for English and several other major languages, with a focus on detailed definitions and linguistic analysis.
• Developer Mozilla Locale API: While not a dictionary, the Web API provides locale-specific information which can be useful for broader internationalization efforts alongside dictionary services.

Getting started

To begin using the Indonesia Dictionary API, you typically need to obtain an API key from their platform. Once you have your key, you can make HTTP requests to the API endpoints. Below is a Python example demonstrating how to retrieve an English-Indonesian definition for the word "hello".

Before running, ensure you have the requests library installed (pip install requests).

import requests
import json

# Replace with your actual API Key
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.indonesiandictionary.com/v1"

headers = {
    "x-api-key": API_KEY
}

def get_english_to_indonesian_definition(word):
    endpoint = f"{BASE_URL}/en-id/define/{word}"
    try:
        response = requests.get(endpoint, headers=headers)
        response.raise_for_status()  # Raise an exception for HTTP errors
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")
    return None

# Example usage:
word_to_lookup = "hello"
definition_data = get_english_to_indonesian_definition(word_to_lookup)

if definition_data:
    print(f"Definition for '{word_to_lookup}':")
    if definition_data.get("data") and definition_data["data"].get("definitions"):
        for entry in definition_data["data"]["definitions"]:
            print(f"  - Part of Speech: {entry.get('part_of_speech', 'N/A')}")
            print(f"    Definition: {entry.get('definition', 'N/A')}")
            if entry.get('examples'):
                print("    Examples:")
                for example in entry['examples']:
                    print(f"      - {example}")
    else:
        print("No definitions found.")
else:
    print(f"Could not retrieve definition for '{word_to_lookup}'.")

This Python script defines a function get_english_to_indonesian_definition that constructs a request to the API, including the necessary API key in the headers. It then prints the retrieved definition data, including parts of speech and example sentences, if available. Remember to replace "YOUR_API_KEY" with your actual API key obtained from the Indonesia Dictionary API documentation.