Getting Started Guide

Quick Start Guide

Get up and running with GetTranslated.AI in just a few simple steps! It's easy to get started, and our platform SDK provides advanced functionality for all your translation needs.

Platform Integration

// Install the SDK
npm install @gettranslated/react-native-sdk

// Create a base translation file, and run the GetTranslated CLI to generate the translation files for your languages.
// Your base language file might look something like this:
{
  "hello": "Hello",
  "message_count": "You have {{count}} messages"
}

// Basic setup with TranslationProvider
import React from 'react';
import { TranslationProvider, useTranslation } from '@gettranslated/react-native-sdk';

// Load translation resources. These should be the same languages configured in your project.
import enTranslations from './src/i18n/locales/en.json';
import esTranslations from './src/i18n/locales/es.json';
import frTranslations from './src/i18n/locales/fr.json';

const translationResources = {
  en: { translation: enTranslations },
  es: { translation: esTranslations },
  fr: { translation: frTranslations },
};

// Wrap your app with TranslationProvider
export default function App() {
  return (
    <TranslationProvider apiKey="your-client-api-key" resources="{translationResources}">
      <MainScreen />
    </TranslationProvider>
  );
}

// Use translations in components
function MainScreen() {
  const { t } = useTranslation();

  return (
    <View>
      <Text>{t('hello')}</Text>
      <Text>{t('message_count', { count: props.count })}</Text>
    </View>
  );
}

// 1. Add SDK from Maven Central to your build.gradle
implementation 'ai.gettranslated:android-sdk:1.0.0'

// 2. Initialize in Application class
import ai.gettranslated.sdk.GetTranslated;

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        GetTranslated.init(getApplicationContext(), "your-ck-api-key");
    }
}

// 3. Use in your activities
String translated = GetTranslated.getDynamicString("Hello, World!");

// Or with callback for async translations
GetTranslated.getDynamicString("Hello, World!", new GetTranslated.TranslationCallback() {
    @Override
    public void onTranslationReady(String translation) {
        runOnUiThread(() -> {
            textView.setText(translation);
        });
    }
    
    @Override
    public void onTranslationError(String errorMessage) {
        // Handle error
    }
});

// 4. Language management
GetTranslated.setLanguage("es"); // Switch to Spanish
Set<String> languages = GetTranslated.getLanguages(); // Get supported languages

// 1. Add via Swift Package Manager
// In Xcode: File → Add Packages... → https://github.com/get-translated/ios-sdk.git
// Or via CocoaPods: pod 'GetTranslatedSDK', '~> 1.0.0'

// 2. Initialize in AppDelegate
import GetTranslatedSDK

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    GetTranslated.initialize(key: "your-ck-api-key")
    return true
}

// 3. Use in your view controllers
let translated = GetTranslated.getDynamicString("Hello, World!")

// Or with callback for async translations
GetTranslated.getDynamicString("Hello, World!") { translation in
    DispatchQueue.main.async {
        label.text = translation
    }
} onError: { error in
    print("Translation error: \(error)")
}

// 4. Language management (optional - SDK handles automatically)
GetTranslated.setLanguage("es") // Switch to Spanish
let languages = GetTranslated.getLanguages() // Get supported languages

Best Practices

• Review All Translations

  Always review AI-generated translations before shipping to production. Human review ensures accuracy and cultural appropriateness.

• Use Translation Memory

  Leverage translation memory to maintain consistency across your apps.

• Use Protected Words

  Leverage protected words to prevent brand names, trademarks, and other important words or phrasesfrom being translated.

• Test with Real Users

  Test your translated app with native speakers to ensure the translations work well in context.

• Plan for Text Expansion

  Some languages require more space than others. Design your UI to accommodate longer text.

• Initialize SDK Early

  Initialize the SDK as early as possible in your app lifecycle (e.g., in Application.onCreate() for Android or AppDelegate for iOS). This ensures translations are ready before your UI loads and language preferences are applied correctly.

• Handle Errors Gracefully

  Always provide fallback text when translations fail. Use error callbacks to handle network errors and show the original text as a fallback. Implement retry logic for transient network failures.

• Secure Your API Keys

  Never commit API keys to version control. Use environment variables, secure configuration files (like .gettranslated), or your platform's secure storage. Add configuration files containing keys to .gitignore.

• Leverage Offline Caching

  The SDK automatically caches translations locally. Pre-load critical translations during app initialization to ensure they're available offline. Test your app's offline behavior to ensure a smooth user experience.

• Use Async Translations for UI

  Use callback-based or async translation methods for UI updates to prevent blocking the main thread. Show loading states while translations are being fetched, especially for dynamic content.

• Validate Language Support

  Before setting a language, check if it's supported by your project using getLanguages(). This prevents errors and provides a better user experience. Persist user language preferences across app restarts.

• Test All Supported Languages

  Test your app with all languages you've configured in your project. Verify UI layout, text rendering, and cultural appropriateness. Don't forget to test offline scenarios and error handling for each language.

• Optimize Performance

  Batch related translation requests when possible. Pre-load critical translations during initialization. Use the SDK's built-in caching rather than implementing your own caching layer unless you have specific requirements.