Name: Language Detector API: 55+ Languages, Instant & Accurate
Brand: viv-data
SKU: api-viv-data-lang-detect
Availability: InStock
Author: API Market

gia ly bui

# Language Detector — 55+ Languages, Instant

## Overview
The Language Detector API provides real-time, highly accurate language identification for over 55 languages. This robust AI model allows developers to instantly detect the language of any given text, complete with a confidence score. Built for speed and reliability, it operates offline without requiring external API calls, making it ideal for applications demanding low latency and privacy, such as multilingual content processing, intelligent chatbots, and efficient content moderation systems.

## Features
*   **Comprehensive Language Support:** Accurately identifies over 55 distinct languages.
*   **Confidence Scores:** Provides a confidence level for each detected language, allowing for nuanced decision-making.
*   **Instant Real-time Detection:** Delivers immediate results, crucial for interactive applications.
*   **Offline Operation:** Powered by Google's Compact Language Detector (CLD3), the model runs locally, ensuring low latency and data privacy.
*   **No API Keys Required (for underlying model):** The core CLD3 model does not require separate API keys, simplifying integration (though an API.market key is needed for platform access).
*   **Versatile Applications:** Suitable for diverse use cases from content categorization to user experience personalization.

## Use Cases
*   **Multilingual Content Moderation:** Automatically flag or route user-generated content in various languages to the appropriate moderation teams, enhancing efficiency and compliance across global platforms.
*   **Chatbot and Customer Service Automation:** Enable chatbots to instantly identify the user's language and respond in the correct language, improving user experience and reducing the need for manual language selection.
*   **Dynamic Content Localization:** Automatically detect the language of incoming user queries or data streams to serve localized content or advertisements in real-time, personalizing user interactions.
*   **SEO and Content Categorization:** Organize vast libraries of text content by language for better search engine indexing, content management, and analytical purposes.
*   **Educational Platforms:** Assist language learners by identifying the language of text inputs, providing real-time feedback or translation prompts.



## Pricing
Different pricing tiers are available based on usage volume. For the Language Detector API, 1 API unit equals 1 request processed to the `/detect` endpoint.

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/viv-data/lang-detect`

### Authentication
Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Processing Mode
This API operates in **Synchronous Processing** mode. This means that a single request to an endpoint will directly return the final result in its response. There are no job IDs, no polling loops, and no separate status checks required. The client should implement an appropriate request timeout, especially for applications where network latency or processing duration could be a factor.

### Endpoints

#### `GET /detect`
Detects the language of a given text string.

**Summary:** Detect Language
**Operation ID:** `detect_language_detect_get`

**Parameters:**

| Name | In    | Type   | Required | Description                 |
| :--- | :---- | :----- | :------- | :-------------------------- |
| `text` | query | string | true     | Text to detect language of. |

**Example Request:**
```bash
curl -X GET "https://prod.api.market/api/v1/viv-data/lang-detect/detect?text=Bonjour%20le%20monde" -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{
  "text": "Bonjour le monde",
  "language": "fr",
  "language_name": "French",
  "confidence": 0.98
}
```

**Response Schema (`DetectResult`):**

| Property        | Type   | Description                                |
| :-------------- | :----- | :----------------------------------------- |
| `text`          | string | The original text that was analyzed.       |
| `language`      | string | The ISO 639-1 code of the detected language (e.g., "en", "fr"). |
| `language_name` | string | The full name of the detected language (e.g., "English", "French"). |
| `confidence`    | number | A score between 0 and 1 indicating the confidence of the detection. |

#### `GET /health`
Performs a health check on the API service.

**Summary:** Health
**Operation ID:** `health_health_get`

**Example Request:**
```bash
curl -X GET "https://prod.api.market/api/v1/viv-data/lang-detect/health" -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{}
```

## Status Codes
*   **200 OK:** Request successful. The API processed the request and returned the expected data.
*   **201 Created:** Resource successfully created. (Not typically used by this synchronous API, but included for completeness).
*   **400 Bad Request:** Invalid input parameters or malformed request. Check the request body or query parameters for errors. For the `/detect` endpoint, this might mean the `text` parameter is missing or malformed.
*   **401 Unauthorized:** Missing or invalid API key. Ensure your `x-api-market-key` header is present and contains a valid API key.
*   **403 Forbidden:** Valid API key but insufficient permissions. Your API key does not have the necessary access rights for the requested operation.
*   **404 Not Found:** The requested resource was not found. Check the endpoint URL for typos.
*   **422 Unprocessable Entity:** Validation Error. The server understands the content type and the syntax of the request entity is correct, but it was unable to process the contained instructions. Often indicates issues with data types or constraints for input parameters.
*   **429 Too Many Requests:** Rate limit exceeded. You have sent too many requests in a given amount of time. Implement retry logic with exponential backoff.
*   **500 Internal Server Error:** Server-side error. An unexpected error occurred on the API server. This typically indicates an issue on our end; please report it if it persists.
*   **503 Service Unavailable:** Service temporarily unavailable. The server is currently unable to handle the request due to a temporary overload or scheduled maintenance.



## Implementation Guide

### Example Code

Since this is a synchronous API, the examples demonstrate a single request that returns the final result directly.

#### JavaScript
```javascript
// JavaScript example for synchronous API call
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/viv-data/lang-detect";

async function detectLanguage(textToDetect) {
  try {
    const encodedText = encodeURIComponent(textToDetect);
    const url = `${baseUrl}/detect?text=${encodedText}`;

    const response = await fetch(url, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey
      }
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API error: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
    }

    const result = await response.json();
    return result;
  } catch (error) {
    console.error("Error detecting language:", error);
    throw error;
  }
}

// Example usage:
(async () => {
  try {
    const text = "Hola mundo";
    const detectionResult = await detectLanguage(text);
    console.log("Detected Language:", detectionResult);
    // Expected output: { text: "Hola mundo", language: "es", language_name: "Spanish", confidence: 0.99 }

    const text2 = "This is an example sentence.";
    const detectionResult2 = await detectLanguage(text2);
    console.log("Detected Language 2:", detectionResult2);

  } catch (e) {
    console.error("Application error:", e);
  }
})();
```

#### Python
```python
# Python example for synchronous API call
import requests
import json

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/viv-data/lang-detect"

def detect_language(text_to_detect):
    headers = {
        "x-api-market-key": API_KEY
    }
    params = {
        "text": text_to_detect
    }
    
    try:
        response = requests.get(f"{BASE_URL}/detect", headers=headers, params=params)
        response.raise_for_status()  # Raises HTTPError for bad responses (4xx or 5xx)
        
        result = response.json()
        return result
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err} - {response.text}")
        raise
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
        raise
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
        raise
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")
        raise

# Example usage:
if __name__ == "__main__":
    try:
        text = "Hello world"
        detection_result = detect_language(text)
        print("Detected Language:", json.dumps(detection_result, indent=2))
        # Expected output: { "text": "Hello world", "language": "en", "language_name": "English", "confidence": 0.99 }

        text2 = "Comment allez-vous?"
        detection_result2 = detect_language(text2)
        print("Detected Language 2:", json.dumps(detection_result2, indent=2))

    except Exception as e:
        print(f"Application error: {e}")
```

#### cURL
```bash
# cURL example for synchronous API call

# Example 1: Detect language of "Hello world"
curl -X GET "https://prod.api.market/api/v1/viv-data/lang-detect/detect?text=Hello%20world" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Expected Response:
# {
#   "text": "Hello world",
#   "language": "en",
#   "language_name": "English",
#   "confidence": 0.99
# }

# Example 2: Detect language of "Guten Tag"
curl -X GET "https://prod.api.market/api/v1/viv-data/lang-detect/detect?text=Guten%20Tag" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Expected Response:
# {
#   "text": "Guten Tag",
#   "language": "de",
#   "language_name": "German",
#   "confidence": 0.98
# }
```


## FAQ
**Q: How many languages does the API support?**

A: The API supports detection for over 55 languages, including major global languages and many others.

**Q: Can I use this API for real-time applications like chatbots?**

A: Yes, the API is designed for instant, real-time language detection, making it perfect for chatbots, live content processing, and interactive applications.

**Q: Does the API provide a confidence score for its predictions?**

A: Yes, every language detection result includes a confidence score, indicating the model's certainty about the detected language.

**Q: What is the underlying technology used for language detection?**

A: The API is powered by Google's Compact Language Detector (CLD3), ensuring high accuracy and efficient offline operation.

**Q: Do I need an API key for the underlying CLD3 model?**

A: The core CLD3 model itself does not require an API key. However, you will need an API.market API key (`x-api-market-key`) to access this API endpoint.

**Q: What happens if the language cannot be confidently detected?**

A: In cases of very short or ambiguous text, the confidence score might be low, or the API might default to a common language. Your application should handle low confidence scores appropriately (e.g., prompting the user for clarification).

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.

Utilize this powerful Language Detector API to instantly identify text language across 55+ languages, providing confidence scores for accurate content processin