Atlas API API Reference

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class AtlasApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _publicKey;
    private readonly string _secretKey;

    public AtlasApiClient(string publicKey, string secretKey)
    {
        _publicKey = publicKey;
        _secretKey = secretKey;
        _httpClient = new HttpClient();
    }

    public async Task<string> GetCountriesAsync(string language = "en")
    {
        var request = new HttpRequestMessage(HttpMethod.Get, 
            "https://atlasapi.solvytix.com/api/Countries");
        
        request.Headers.Add("X-Public-Key", _publicKey);
        request.Headers.Add("X-Secret-Key", _secretKey);
        request.Headers.Add("Accept-Language", language);  // "en" or "ar"

        var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadAsStringAsync();
    }
}

// Example usage
var client = new AtlasApiClient("your_public_key", "your_secret_key");
var countries = await client.GetCountriesAsync("en");  // English
var countriesAr = await client.GetCountriesAsync("ar");  // Arabic

import requests

class AtlasApiClient:
    def __init__(self, public_key, secret_key):
        self.public_key = public_key
        self.secret_key = secret_key
        self.base_url = "https://atlasapi.solvytix.com/api"
    
    def get_countries(self, language='en'):
        """
        Get countries list
        language: 'en' for English, 'ar' for Arabic
        """
        headers = {
            'X-Public-Key': self.public_key,
            'X-Secret-Key': self.secret_key,
            'Accept-Language': language
        }
        
        response = requests.get(
            f'{self.base_url}/Countries',
            headers=headers
        )
        response.raise_for_status()
        return response.json()

# Example usage
client = AtlasApiClient('your_public_key', 'your_secret_key')

# Get countries in English
countries = client.get_countries('en')

# Get countries in Arabic
countries_ar = client.get_countries('ar')

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class AtlasApiClient {
    private final HttpClient httpClient;
    private final String publicKey;
    private final String secretKey;
    private static final String BASE_URL = "https://atlasapi.solvytix.com/api";

    public AtlasApiClient(String publicKey, String secretKey) {
        this.publicKey = publicKey;
        this.secretKey = secretKey;
        this.httpClient = HttpClient.newHttpClient();
    }

    public String getCountries(String language) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/Countries"))
            .header("X-Public-Key", publicKey)
            .header("X-Secret-Key", secretKey)
            .header("Accept-Language", language)  // "en" or "ar"
            .GET()
            .build();

        HttpResponse<String> response = httpClient.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );

        return response.body();
    }

    // Example usage
    public static void main(String[] args) throws Exception {
        AtlasApiClient client = new AtlasApiClient(
            "your_public_key", 
            "your_secret_key"
        );
        
        // Get countries in English
        String countries = client.getCountries("en");
        
        // Get countries in Arabic
        String countriesAr = client.getCountries("ar");
    }
}

const axios = require('axios');

class AtlasApiClient {
  constructor(publicKey, secretKey) {
    this.publicKey = publicKey;
    this.secretKey = secretKey;
    this.baseURL = 'https://atlasapi.solvytix.com/api';
  }

  async getCountries(language = 'en') {
    try {
      const response = await axios.get(`${this.baseURL}/Countries`, {
        headers: {
          'X-Public-Key': this.publicKey,
          'X-Secret-Key': this.secretKey,
          'Accept-Language': language  // 'en' for English, 'ar' for Arabic
        }
      });
      return response.data;
    } catch (error) {
      console.error('Error fetching countries:', error.message);
      throw error;
    }
  }

  async getGovernorates(countryId, language = 'en') {
    try {
      const response = await axios.get(
        `${this.baseURL}/Governorates/${countryId}`, 
        {
          headers: {
            'X-Public-Key': this.publicKey,
            'X-Secret-Key': this.secretKey,
            'Accept-Language': language
          }
        }
      );
      return response.data;
    } catch (error) {
      console.error('Error fetching governorates:', error.message);
      throw error;
    }
  }
}

// Example usage
const client = new AtlasApiClient('your_public_key', 'your_secret_key');

// Get countries in English
client.getCountries('en')
  .then(data => console.log('Countries (EN):', data))
  .catch(err => console.error(err));

// Get countries in Arabic
client.getCountries('ar')
  .then(data => console.log('Countries (AR):', data))
  .catch(err => console.error(err));