> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reverieinc.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Getting Started

> The Transliteration API is a REST API used to transliterate the content from English to Indic languages and vice-versa. 

In this guide, you’ll learn how to automatically transcribe live streaming audio in real time using Reverie's SDKs, which are supported for use with the Reverie API.

> [!NOTE]
>
> Before you start, you'll need to follow the steps in the [Get your API
> Credentials](https://docs.reverieinc.com/authentication.md) to obtain your API KEY & APP ID.

### Make your first Call

Make your first API Call using the cURL request. Add your own API Credentials where it says `<YOUR-APP-ID>` & `<YOUR-API-KEY>`
and then run the following example in a terminal or your favorite API client.

```bash theme={null}
curl --location --request POST 'https://revapi.reverieinc.com/' \
--header 'Content-Type: application/json' \
--header 'REV-API-KEY: <YOUR API-KEY>' \
--header 'REV-APP-ID: <YOUR APP-ID>' \
--header 'src_lang: en' \
--header 'tgt_lang: hi' \
--header 'domain: 1' \
--header 'cnt_lang: en' \
--header 'REV-APPNAME: transliteration' \
--data-raw '{"data": ["Reverie Language Technologies ltd website address is www.reverieinc.com"],
}'
```

By default, The API will return the strings in the target language.

### SDKs

Reverie has several SDKs that can make it easier to use the API.
Follow these steps to use the SDK of your choice to make a Reverie Transliteration request.

### Install Dependencies

```bash JavaScript theme={null}
npm i @reverieit/reverie-client
```

```bash Python theme={null}
pip install reverie-sdk
```

### Transliterate Text to your preferred language

The following code shows how to convert the text to your preferred language.

```javascript JavaScript theme={null}
const ReverieClient = require("@reverieit/reverie-client");

const reverieClient = new ReverieClient({
  apiKey: "YOUR-API-KEY",
  appId: "YOUR-APP-ID",
});

async function transliterateText() {
  const translation = await reverieClient.transliterate({
    text: "Namaste",
    src_lang: "en",
    tgt_lang: "ta",
  });
  console.log(translation);
}

transliterateText();
```

```python Python theme={null}
from reverie_sdk import ReverieClient

client = ReverieClient(
    api_key="MY_API_KEY",
    app_id="MY_APP_ID",
)

res = client.t13n.transliteration(
    data=[
        "Reverie Language Technologies is located in Bengaluru ",
        "The address is Jio Avana, Bellandur, Bengaluru -560102",
        "The website address is www.reverieinc.com.",
    ],
    src_lang="en",
    cnt_lang="en",
    tgt_lang="hi",
    noOfSuggestions=2,
)

print(res)
```

```go Go theme={null}
package main

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

const (
	apiURL     = "https://revapi.reverieinc.com/"
	apiKey     = "<YOUR API KEY>"
	appID      = "<YOUR APP ID>"
)

type RequestBody struct {
	Data                 []string `json:"data"`
	IsBulk               bool     `json:"isBulk"`
	IgnoreTaggedEntities bool     `json:"ignoreTaggedEntities"`
}

type APIResponse struct {
	ResponseList []struct {
		APIStatus int      `json:"apiStatus"`
		InString  string   `json:"inString"`
		OutString []string `json:"outString"`
	} `json:"responseList"`
}
func main() {
	text := "Reverie Language Technologies ltd website address is www.reverieinc.com"
	requestBody := map[string]interface{}{
		"data":                 []string{text},
		"isBulk":               false,
		"ignoreTaggedEntities": false,
	}

	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		log.Fatalf("Error marshaling JSON: %v", err)
	}

	req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
	if err != nil {
		log.Fatalf("Error creating request: %v", err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("REV-API-KEY", apiKey)
	req.Header.Set("REV-APP-ID", appID)
	req.Header.Set("src_lang", "en")
	req.Header.Set("tgt_lang", "hi")
	req.Header.Set("domain", "1")
	req.Header.Set("cnt_lang", "en")
	req.Header.Set("REV-APPNAME", "transliteration")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Fatalf("Error making request: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("Error reading response body: %v", err)
	}

	var apiResponse APIResponse
	err = json.Unmarshal(body, &apiResponse)
	if err != nil {
		log.Fatalf("Error unmarshaling response: %v", err)
	}

	if len(apiResponse.ResponseList) > 0 && len(apiResponse.ResponseList[0].OutString) > 0 {
		fmt.Println("Transliterated text:", apiResponse.ResponseList[0].OutString[0])
	} else {
		fmt.Println("No response from API")
	}
}
```

### Results

In order to see the results from Reverie, you must run the application. Run your application from the terminal. Your transcripts will appear in your shell.

```bash JavaScript theme={null}
# Run your application using the file you created in the previous step
# Example:
npm start
```

```python Python theme={null}
# Run your application using the file you created in the previous step
# Example:
python main.py
```

```go GoLang theme={null}
// Run your application using the file you created in the previous step
// Example:
go run main.go
```

### Analyzing the Response

The API returns a `responseList`, which is an array containing the transliterated content. Each item includes the `inString`, representing the original text in the source script, and the corresponding `outString`, which is the result of converting that text into the target script. Additionally, the response includes an `api_status` field, where a value of `2` indicates a successful transaction.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.