Codealo Routes API

API REST completa para geolocalización, rutas y mapas diseñada específicamente para América Latina

🚀 Base URL

https://routes.codealo.com.ar

Características principales

✅ Optimizado para direcciones de LATAM
✅ Soporte multi-proveedor (Google, Mapbox, OpenStreetMap)
✅ Respuestas rápidas y confiables
✅ Documentación completa con ejemplos
✅ Formato JSON estándar

⚡ Quick Start - 5 minutos

Guía rápida para comenzar a usar Codealo Routes API en menos de 5 minutos.

Obtener API Key

Para usar la API necesitás una API Key. Es gratis y solo toma unos segundos obtenerla.

Visitá nuestra página de contacto
Completá el formulario solicitando tu API Key
Recibirás tu API Key por email en minutos

Obtener API Key gratis →

Primer Request Exitoso

Probá la API con un request simple usando cURL. Reemplazá YOUR_API_KEY con tu API Key real.

curl -X GET "https://routes.codealo.com.ar/geocode?address=Av.%20Corrientes%201000,%20Buenos%20Aires,%20Argentina" \
    -H "x-api-key: YOUR_API_KEY"

✅ Respuesta esperada: Deberías recibir coordenadas (lat y lng) en formato JSON.

Integración Básica

Ejemplo de integración básica en JavaScript para geocodificar una dirección:

async function geocodeAddress(address) {
    const params = new URLSearchParams({
        address: address
    });
    
    const response = await fetch(`https://routes.codealo.com.ar/geocode?${params}`, {
        method: 'GET',
        headers: {
        'x-api-key': 'YOUR_API_KEY'
        }
    });
    
    const data = await response.json();
    console.log('Coordenadas:', data.lat, data.lng);
    return data;
    }

    // Uso
    geocodeAddress('Av. Corrientes 1000, Buenos Aires, Argentina')
    .then(result => {
        console.log('Dirección formateada:', result.formattedAddress);
    });

💡 Tip: Revisá la documentación completa de cada endpoint para ver más ejemplos en React, Angular, Python y más.

📦 Recursos Adicionales

Descargá la especificación OpenAPI, consultá los ejemplos de requests/responses o importá la colección de Postman para probar la API fácilmente.

Descargar OpenAPI Spec Ejemplos (requests/responses)

🔐 Autenticación

Todas las requests a la API requieren autenticación mediante una API Key. La API Key debe ser enviada en el header de cada request.

Header Requerido

Incluí tu API Key en el header x-api-key de cada request.

x-api-key: YOUR_API_KEY

📝 Cómo Obtener tu API Key

Visitá nuestra página de contacto
Completá el formulario solicitando tu API Key
Recibirás tu API Key por email en minutos
Guardá tu API Key de forma segura (no la compartas públicamente)

Obtener API Key gratis →

curl -X GET "https://routes.codealo.com.ar/geocode?address=Av.%20Corrientes%201000,%20Buenos%20Aires,%20Argentina" \
    -H "x-api-key: YOUR_API_KEY"

const params = new URLSearchParams({
    address: 'Av. Corrientes 1000, Buenos Aires, Argentina'
    });

    const response = await fetch(`https://routes.codealo.com.ar/geocode?${params}`, {
    method: 'GET',
    headers: {
        'x-api-key': 'YOUR_API_KEY'
    }
    });

    const data = await response.json();
    console.log(data);

import { useState } from 'react';

    function ApiComponent() {
    const API_KEY = 'YOUR_API_KEY';
    
    const makeRequest = async () => {
        try {
        const params = new URLSearchParams({
            address: 'Av. Corrientes 1000, Buenos Aires, Argentina'
        });
        
        const response = await fetch(`https://routes.codealo.com.ar/geocode?${params}`, {
            method: 'GET',
            headers: {
            'x-api-key': API_KEY
            }
        });
        
        const data = await response.json();
        console.log(data);
        } catch (error) {
        console.error('Error:', error);
        }
    };
    
    return (
        
    );
    }

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
    import { Injectable } from '@angular/core';

    @Injectable({
    providedIn: 'root'
    })
    export class ApiService {
    private apiKey = 'YOUR_API_KEY';
    private baseUrl = 'https://routes.codealo.com.ar';
    
    constructor(private http: HttpClient) {}
    
    makeRequest() {
        const headers = new HttpHeaders({
        'x-api-key': this.apiKey
        });
        
        const params = new HttpParams()
        .set('address', 'Av. Corrientes 1000, Buenos Aires, Argentina');
        
        return this.http.get(`${this.baseUrl}/geocode`, { headers, params });
    }
    }

import requests

    api_key = "YOUR_API_KEY"
    url = "https://routes.codealo.com.ar/geocode"

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

    params = {
        "address": "Av. Corrientes 1000, Buenos Aires, Argentina"
    }

    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    print(data)

⚠️ Seguridad

🔒 Nunca compartas tu API Key públicamente (no la subas a repositorios públicos, no la incluyas en código cliente visible)
🔑 Rota tu API Key periódicamente si sospechás que ha sido comprometida
📊 Monitoreá el uso de tu API Key para detectar actividad sospechosa
🚫 No uses la misma API Key en desarrollo y producción

GET

/geocode

Convierte una dirección en formato legible a coordenadas geográficas (latitud y longitud). El servicio utiliza el proveedor de mapas especificado o el predeterminado.

Parámetros de Query

Campo	Tipo	Requerido	Descripción
address	string	SI	Dirección completa en formato legible (1-500 caracteres)
country	string	NO	Código de país ISO 3166-1 alpha-2 (2 letras mayúsculas). Ej: AR, BR, MX, US
provider	string	NO	Proveedor de geocodificación: `google` (default), `mapbox`, `distanceMatrix`, `openStreetMap`, `openCage`

curl -X GET "https://routes.codealo.com.ar/geocode?address=Av.%20Corrientes%201000,%20Buenos%20Aires,%20Argentina&country=AR" \
    -H "x-api-key: YOUR_API_KEY"

const params = new URLSearchParams({
    address: 'Av. Corrientes 1000, Buenos Aires, Argentina',
    country: 'AR'
    });

    const response = await fetch(`https://routes.codealo.com.ar/geocode?${params}`, {
    method: 'GET',
    headers: {
        'x-api-key': 'YOUR_API_KEY'
    }
    });

    const data = await response.json();
    console.log(data);

import { useState } from 'react';

    function GeocodeComponent() {
    const [result, setResult] = useState(null);
    
    const geocodeAddress = async () => {
        try {
        const params = new URLSearchParams({
            address: 'Av. Corrientes 1000, Buenos Aires, Argentina',
            country: 'AR'
        });
        
        const response = await fetch(`https://routes.codealo.com.ar/geocode?${params}`, {
            method: 'GET',
            headers: {
            'x-api-key': 'YOUR_API_KEY'
            }
        });
        
        const data = await response.json();
        setResult(data);
        } catch (error) {
        console.error('Error:', error);
        }
    };
    
    return (
        
        
        {result && {JSON.stringify(result, null, 2)}}
        
    );
    }

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
    import { Injectable } from '@angular/core';

    @Injectable({
    providedIn: 'root'
    })
    export class GeocodeService {
    private apiUrl = 'https://routes.codealo.com.ar/geocode';
    private apiKey = 'YOUR_API_KEY';
    
    constructor(private http: HttpClient) {}
    
    geocodeAddress(address: string, country?: string) {
        const headers = new HttpHeaders({
        'x-api-key': this.apiKey
        });
        
        let params = new HttpParams().set('address', address);
        if (country) {
        params = params.set('country', country);
        }
        
        return this.http.get(this.apiUrl, { headers, params });
    }
    }

    // En tu componente:
    // this.geocodeService.geocodeAddress('Av. Corrientes 1000, Buenos Aires, Argentina', 'AR')
    //   .subscribe(data => console.log(data));

import requests

    url = "https://routes.codealo.com.ar/geocode"
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    params = {
        "address": "Av. Corrientes 1000, Buenos Aires, Argentina",
        "country": "AR"
    }

    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    print(data)

Response

{
    "lat": -34.6037,
    "lng": -58.3816,
    "formattedAddress": "Av. Corrientes 1000, C1043 CABA, Argentina",
    "accuracy": "rooftop"
    }

Atributos del Response

Campo	Tipo	Requerido	Descripción
lat	number	SI	Latitud de la ubicación (-90 a 90)
lng	number	SI	Longitud de la ubicación (-180 a 180)
formattedAddress	string	SI	Dirección formateada completa
accuracy	string	SI	Nivel de precisión: `rooftop` (máxima precisión), `range_interpolated`, `geometric_center`, `approximate`

GET

/reverseGeocode

Convierte coordenadas geográficas (latitud y longitud) en una dirección legible. El servicio utiliza el proveedor de mapas especificado o el predeterminado.

Parámetros de Query

Campo	Tipo	Requerido	Descripción
lat	number	SI	Latitud de la ubicación (-90 a 90)
lng	number	SI	Longitud de la ubicación (-180 a 180)
provider	string	NO	Proveedor de geocodificación: `google` (default), `mapbox`, `distanceMatrix`, `openStreetMap`, `openCage`

curl -X GET "https://routes.codealo.com.ar/reverseGeocode?lat=-34.6037&lng=-58.3816" \
    -H "x-api-key: YOUR_API_KEY"

const params = new URLSearchParams({
    lat: -34.6037,
    lng: -58.3816
    });

    const response = await fetch(`https://routes.codealo.com.ar/reverseGeocode?${params}`, {
    method: 'GET',
    headers: {
        'x-api-key': 'YOUR_API_KEY'
    }
    });

    const data = await response.json();
    console.log(data);

import { useState } from 'react';

    function ReverseGeocodeComponent() {
    const [result, setResult] = useState(null);
    
    const reverseGeocode = async (lat, lng) => {
        try {
        const params = new URLSearchParams({
            lat: lat.toString(),
            lng: lng.toString()
        });
        
        const response = await fetch(`https://routes.codealo.com.ar/reverseGeocode?${params}`, {
            method: 'GET',
            headers: {
            'x-api-key': 'YOUR_API_KEY'
            }
        });
        
        const data = await response.json();
        setResult(data);
        } catch (error) {
        console.error('Error:', error);
        }
    };
    
    return (
        
        
        {result && {JSON.stringify(result, null, 2)}}
        
    );
    }

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
    import { Injectable } from '@angular/core';

    @Injectable({
    providedIn: 'root'
    })
    export class ReverseGeocodeService {
    private apiUrl = 'https://routes.codealo.com.ar/reverseGeocode';
    private apiKey = 'YOUR_API_KEY';
    
    constructor(private http: HttpClient) {}
    
    reverseGeocode(lat: number, lng: number) {
        const headers = new HttpHeaders({
        'x-api-key': this.apiKey
        });
        
        const params = new HttpParams()
        .set('lat', lat.toString())
        .set('lng', lng.toString());
        
        return this.http.get(this.apiUrl, { headers, params });
    }
    }

    // En tu componente:
    // this.reverseGeocodeService.reverseGeocode(-34.6037, -58.3816)
    //   .subscribe(data => console.log(data));

import requests

    url = "https://routes.codealo.com.ar/reverseGeocode"
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    params = {
        "lat": -34.6037,
        "lng": -58.3816
    }

    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    print(data)

Response

{
    "formattedAddress": "1600 Amphitheatre Parkway, Mountain View, CA 94043, USA",
    "address": {
        "streetNumber": "1600",
        "route": "Amphitheatre Parkway",
        "neighborhood": "North Bayshore",
        "locality": "Mountain View",
        "city": "Santa Clara County",
        "state": "California",
        "stateIsoCode": "US-CA",
        "country": { "name": "United States", "code": "US" },
        "postalCode": "94043"
    },
    "location": { "lat": 37.4224764, "lng": -122.0842499 },
    "placeId": "ChIJ2eUgeAK6j4ARbn5u_wAGqWA",
    "timezone": "America/Los_Angeles",
    "metadata": {
        "locationType": "ROOFTOP",
        "types": ["street_address"]
    }
    }

Atributos del Response

Campo	Tipo	Requerido	Descripción
formattedAddress	string	SI	Dirección completa formateada
address	object	SI	Objeto con componentes de la dirección
address.streetNumber	string	NO	Número de calle
address.route	string	NO	Nombre de la calle o ruta
address.neighborhood	string	NO	Barrio o vecindario
address.locality	string	NO	Localidad
address.city	string	NO	Ciudad
address.state	string	NO	Estado o provincia
address.stateIsoCode	string	NO	Código ISO 3166-2 del estado (ej: US-CA)
address.country	object	NO	Objeto con nombre y código del país
address.country.name	string	NO	Nombre del país
address.country.code	string	NO	Código ISO 3166-1 del país (ej: US, AR, BR, MX)
address.postalCode	string	NO	Código postal
location	object	SI	Coordenadas de la ubicación
location.lat	number	NO	Latitud
location.lng	number	NO	Longitud
placeId	string	SI	ID único del lugar en el proveedor de mapas
timezone	string	SI	Zona horaria del lugar (ej: America/Los_Angeles)
metadata	object	SI	Metadatos adicionales del lugar
metadata.locationType	string	NO	Tipo de ubicación (ROOFTOP, RANGE_INTERPOLATED, etc)
metadata.types	array	NO	Array de tipos del lugar (street_address, establishment, etc)

POST

/distance

Calcula la distancia y tiempo estimado entre un origen y un destino, con soporte para waypoints intermedios y preferencias de ruta. Incluye advertencias para distancias largas y ajustes por tipo de vehículo.

Parámetros del Request

Campo	Tipo	Requerido	Descripción
origin	string \| object	SI	Dirección o coordenadas de origen
destination	string \| object	SI	Dirección o coordenadas de destino
wayPoints	array	NO	Puntos intermedios
vehicleType	string	NO	Tipo de vehículo (car, minivan, van, truck)
provider	string	NO	Proveedor de mapas: `google` (default), `mapbox`, `distanceMatrix`, `openStreetMap`, `openCage`
preferences	object	NO	Preferencias de ruta (avoidTolls, avoidHighways, departureTime, polylineFormat, etc)

curl -X POST https://routes.codealo.com.ar/distance \
    -H "Content-Type: application/json" \
    -H "x-api-key: YOUR_API_KEY" \
    -d '{
        "origin": "Plaza de Mayo, Buenos Aires, Argentina",
        "destination": "Aeropuerto de Ezeiza, Buenos Aires, Argentina",
        "wayPoints": [
        { "address": "Avenida Medrano 333, Buenos Aires, Argentina" },
        { "address": "Avenida La Playa 1750, Buenos Aires, Argentina" }
        ],
        "vehicleType": "van",
        "preferences": {
        "avoidTolls": false,
        "avoidHighways": false,
        "departureTime": "2025-02-20T08:00:00"
        }
    }'

const response = await fetch('https://routes.codealo.com.ar/distance', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
        origin: 'Plaza de Mayo, Buenos Aires, Argentina',
        destination: 'Aeropuerto de Ezeiza, Buenos Aires, Argentina',
        wayPoints: [
        { address: 'Avenida Medrano 333, Buenos Aires, Argentina' },
        { address: 'Avenida La Playa 1750, Buenos Aires, Argentina' }
        ],
        vehicleType: 'van',
        preferences: {
        avoidTolls: false,
        avoidHighways: false,
        departureTime: '2025-02-20T08:00:00'
        }
    })
    });

    const data = await response.json();
    console.log(data);

import { useState } from 'react';

    function DistanceCalculator() {
    const [distance, setDistance] = useState(null);
    const [loading, setLoading] = useState(false);
    
    const calculateDistance = async () => {
        setLoading(true);
        try {
        const response = await fetch('https://routes.codealo.com.ar/distance', {
            method: 'POST',
            headers: {
            'Content-Type': 'application/json',
            'x-api-key': 'YOUR_API_KEY'
            },
            body: JSON.stringify({
            origin: 'Plaza de Mayo, Buenos Aires, Argentina',
            destination: 'Aeropuerto de Ezeiza, Buenos Aires, Argentina',
            wayPoints: [
                { address: 'Avenida Medrano 333, Buenos Aires, Argentina' },
                { address: 'Avenida La Playa 1750, Buenos Aires, Argentina' }
            ],
            vehicleType: 'van',
            preferences: {
                avoidTolls: false,
                avoidHighways: false,
                departureTime: '2025-02-20T08:00:00'
            }
            })
        });
        
        const data = await response.json();
        setDistance(data);
        } catch (error) {
        console.error('Error:', error);
        } finally {
        setLoading(false);
        }
    };
    
    return (
        
        
        {distance && (
            
            Distancia: {distance.distanceKilometers} km
            Tiempo: {distance.estimatedTimeMinutes} min
            
        )}
        
    );
    }

import { HttpClient, HttpHeaders } from '@angular/common/http';
    import { Injectable } from '@angular/core';
    import { Observable } from 'rxjs';

    interface DistanceRequest {
    origin: string;
    destination: string;
    wayPoints?: { address: string }[];
    vehicleType?: string;
    preferences?: {
        avoidTolls?: boolean;
        avoidHighways?: boolean;
        departureTime?: string;
    };
    }

    @Injectable({
    providedIn: 'root'
    })
    export class DistanceService {
    private apiUrl = 'https://routes.codealo.com.ar/distance';
    private apiKey = 'YOUR_API_KEY';
    
    constructor(private http: HttpClient) {}
    
    calculateDistance(request: DistanceRequest): Observable {
        const headers = new HttpHeaders({
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey
        });
        
        return this.http.post(this.apiUrl, request, { headers });
    }
    }

    // En tu componente:
    // this.distanceService.calculateDistance({
    //   origin: 'Plaza de Mayo, Buenos Aires, Argentina',
    //   destination: 'Aeropuerto de Ezeiza, Buenos Aires, Argentina',
    //   vehicleType: 'van'
    // }).subscribe(data => console.log(data));

import requests

    url = "https://routes.codealo.com.ar/distance"
    headers = {
        "Content-Type": "application/json",
        "x-api-key": "YOUR_API_KEY"
    }
    payload = {
        "origin": "Plaza de Mayo, Buenos Aires, Argentina",
        "destination": "Aeropuerto de Ezeiza, Buenos Aires, Argentina",
        "wayPoints": [
            {"address": "Avenida Medrano 333, Buenos Aires, Argentina"},
            {"address": "Avenida La Playa 1750, Buenos Aires, Argentina"}
        ],
        "vehicleType": "van",
        "preferences": {
            "avoidTolls": False,
            "avoidHighways": False,
            "departureTime": "2025-02-20T08:00:00"
        }
    }

    response = requests.post(url, json=payload, headers=headers)
    data = response.json()
    print(data)

Response

{
    "distanceMeters": 45200,
    "distanceKilometers": 45.2,
    "estimatedTimeMinutes": 60,
    "estimatedTimeWithTrafficMinutes": 65,
    "wayPoints": [
        {
        "distanceMeters": 2100,
        "distanceKilometers": 2.1,
        "estimatedTimeMinutes": 3,
        "estimatedTimeWithTrafficMinutes": 4
        },
        {
        "distanceMeters": 8500,
        "distanceKilometers": 8.5,
        "estimatedTimeMinutes": 10,
        "estimatedTimeWithTrafficMinutes": 12
        },
        {
        "distanceMeters": 34600,
        "distanceKilometers": 34.6,
        "estimatedTimeMinutes": 47,
        "estimatedTimeWithTrafficMinutes": 52
        }
    ],
    "warnings": [
        {
        "code": "WARNING_ESTIMATED_TRAVEL_TIME_MAY_VARY_TO_LONG",
        "message": "The estimated travel time may vary due to long distances."
        }
    ]
    }

Atributos del Response

Campo	Tipo	Descripción
distanceMeters	number	Distancia total en metros
distanceKilometers	number	Distancia total en kilómetros
estimatedTimeMinutes	number	Tiempo estimado de viaje en minutos (sin considerar tráfico)
estimatedTimeWithTrafficMinutes	number	Tiempo estimado de viaje en minutos considerando tráfico actual (si está disponible)
wayPoints	array	Cuando se enviaron waypoints, array con distancia y tiempo por tramo. Cada elemento tiene `distanceMeters`, `distanceKilometers`, `estimatedTimeMinutes`, `estimatedTimeWithTrafficMinutes` (opcional)
warnings	array	Array de advertencias sobre la ruta. Cada advertencia tiene `code` y `message`

GET

/autocomplete

Proporciona sugerencias de lugares basadas en una consulta de texto. Permite filtrar por tipo de lugar, país, estado, ciudad y zona.

Query Parameters

Parámetro	Tipo	Requerido	Descripción
query	string	SI	Texto de búsqueda para autocompletar (1-100 caracteres)
language	string	NO	Idioma de los resultados (ISO 639-1)
types	string	NO	Tipos de lugares a incluir, separados por comas (ej: address,establishment)
country	string	NO	Código de país (ISO 3166-1 alpha-2). Ej: AR, BR, MX
state	string	NO	Nombre del estado o provincia (ej: BuenosAires)
city	string	NO	Nombre de la ciudad
zone	string	NO	Zona específica dentro de la ciudad (ej: Centro)
limit	integer	NO	Límite máximo de sugerencias a retornar (1-10, default 5)
provider	string	NO	Proveedor de autocompletado: `google` (default), `mapbox`, `distanceMatrix`, `openStreetMap`, `openCage`

curl -X GET "https://routes.codealo.com.ar/autocomplete?query=Obel&language=es&types=address&country=AR&state=BuenosAires&city=BuenosAires&zone=Centro&limit=5" \
    -H "x-api-key: YOUR_API_KEY"

const params = new URLSearchParams({
    query: 'Obel',
    language: 'es',
    types: 'address',
    country: 'AR',
    limit: 5
    });

    const response = await fetch(`https://routes.codealo.com.ar/autocomplete?${params}`, {
    headers: {
        'x-api-key': 'YOUR_API_KEY'
    }
    });

    const data = await response.json();
    console.log(data);

import { useState, useEffect } from 'react';

    function AutocompleteSearch() {
    const [query, setQuery] = useState('');
    const [suggestions, setSuggestions] = useState([]);
    
    useEffect(() => {
        if (query.length < 3) {
        setSuggestions([]);
        return;
        }
        
        const fetchSuggestions = async () => {
        const params = new URLSearchParams({
            query: query,
            language: 'es',
            types: 'address',
            country: 'AR',
            limit: 5
        });
        
        try {
            const response = await fetch(
            `https://routes.codealo.com.ar/autocomplete?${params}`,
            {
                headers: { 'x-api-key': 'YOUR_API_KEY' }
            }
            );
            
            const data = await response.json();
            setSuggestions(data.predictions || []);
        } catch (error) {
            console.error('Error:', error);
        }
        };
        
        const timeoutId = setTimeout(fetchSuggestions, 300);
        return () => clearTimeout(timeoutId);
    }, [query]);
    
    return (
        
         setQuery(e.target.value)}
            placeholder="Buscar lugar..."
        />
        
            {suggestions.map((item, index) => (
            {item.description}
            ))}
        
        
    );
    }

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
    import { Injectable } from '@angular/core';
    import { Observable } from 'rxjs';

    @Injectable({
    providedIn: 'root'
    })
    export class AutocompleteService {
    private apiUrl = 'https://routes.codealo.com.ar/autocomplete';
    private apiKey = 'YOUR_API_KEY';
    
    constructor(private http: HttpClient) {}
    
    searchPlaces(query: string, options?: {
        language?: string;
        types?: string;
        country?: string;
        limit?: number;
    }): Observable {
        const headers = new HttpHeaders({
        'x-api-key': this.apiKey
        });
        
        let params = new HttpParams().set('query', query);
        
        if (options) {
        if (options.language) params = params.set('language', options.language);
        if (options.types) params = params.set('types', options.types);
        if (options.country) params = params.set('country', options.country);
        if (options.limit) params = params.set('limit', options.limit.toString());
        }
        
        return this.http.get(this.apiUrl, { headers, params });
    }
    }

    // En tu componente con debounce:
    // searchControl.valueChanges.pipe(
    //   debounceTime(300),
    //   switchMap(query => this.autocompleteService.searchPlaces(query, {
    //     language: 'es',
    //     country: 'AR',
    //     limit: 5
    //   }))
    // ).subscribe(data => this.suggestions = data.predictions);

import requests

    url = "https://routes.codealo.com.ar/autocomplete"
    headers = {"x-api-key": "YOUR_API_KEY"}
    params = {
        "query": "Obel",
        "language": "es",
        "types": "address",
        "country": "AR",
        "limit": 5
    }

    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    print(data)

Response

{
    "predictions": [
        {
        "placeId": "ChIJN1t_tDeuEmsRUsoyG83frY4",
        "description": "Obelisco de Buenos Aires, Avenida 9 de Julio, Buenos Aires, Argentina",
        "types": ["tourist_attraction", "point_of_interest"],
        "location": {"lat": -34.6037, "lng": -58.3816}
        },
        {
        "placeId": "ChIJN1t_tDeuEmsRUsoyG83frY4",
        "description": "Obelisco, Avenida 9 de Julio, Buenos Aires, Argentina",
        "types": ["establishment"],
        "location": {"lat": -34.6037, "lng": -58.3816}
        }
    ],
    "status": "OK"
    }

Atributos del Response

Campo	Tipo	Descripción
predictions	array	Array de predicciones de lugares que coinciden con la búsqueda
predictions[].placeId	string	ID único del lugar en el proveedor de mapas
predictions[].description	string	Descripción legible del lugar
predictions[].types	array	Array de tipos del lugar (address, establishment, tourist_attraction, point_of_interest, etc)
predictions[].location	object	Coordenadas del lugar
predictions[].location.lat	number	Latitud del lugar
predictions[].location.lng	number	Longitud del lugar
status	string	Estado de la respuesta (OK, ZERO_RESULTS, etc)

POST

/directions

Calcula la ruta, distancia y tiempo estimado entre un origen y un destino, con opción de waypoints intermedios.

Parámetros del Request

Campo	Tipo	Requerido	Descripción
origin	string \| object	SI	Dirección o coordenadas {lat, lng} de origen
destination	string \| object	SI	Dirección o coordenadas {lat, lng} de destino
wayPoints	array	NO	Puntos intermedios [{address: string}]
vehicleType	string	NO	Tipo de vehículo (car, minivan, van, truck). Default: van
preferences	object	NO	Preferencias: `avoidTolls` (boolean), `avoidHighways` (boolean), `departureTime` (date-time), `polylineFormat` (geoJSON\|encoded\|polyline6, default: geoJSON), `avoidSteps` (boolean)

📐 Formatos de Polyline

El formato del polyline en el response puede variar según el parámetro preferences.polylineFormat en el request.

geoJSON (default)

Tipo: object

{
    "type": "LineString",
    "coordinates": [
        [-58.3816, -34.6037],  // [lng, lat]
        [-58.3826, -34.6137]
    ]
    }

Uso: Compatible con librerías GeoJSON, fácil de usar en mapas. Default: Si no se especifica polylineFormat, se usa este formato.

encoded

Tipo: string

{
    "polyline": "encoded_polyline_string_from_google_maps"
    }

Uso: String codificado del algoritmo de polyline de Google Maps. Ventaja: Más compacto, menor tamaño de respuesta. Desventaja: Requiere decodificación para usar en mapas.

polyline6

Tipo: string

Estructura: Igual que encoded

Nota: Actualmente se trata igual que encoded en el código.

Ejemplo de uso:

{
    "origin": "Plaza de Mayo, Buenos Aires, Argentina",
    "destination": "Aeropuerto de Ezeiza, Buenos Aires, Argentina",
    "preferences": {
        "polylineFormat": "encoded"  // o "geoJSON" o "polyline6"
    }
    }

curl -X POST https://routes.codealo.com.ar/directions \
    -H "Content-Type: application/json" \
    -H "x-api-key: YOUR_API_KEY" \
    -d '{
        "origin": "Plaza de Mayo, Buenos Aires, Argentina",
        "destination": "Aeropuerto de Ezeiza, Buenos Aires, Argentina",
        "vehicleType": "minivan",
        "preferences": {
        "avoidTolls": false,
        "polylineFormat": "geoJSON"
        }
    }'

const response = await fetch('https://routes.codealo.com.ar/directions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
        origin: 'Plaza de Mayo, Buenos Aires, Argentina',
        destination: 'Aeropuerto de Ezeiza, Buenos Aires, Argentina',
        vehicleType: 'minivan',
        preferences: {
        avoidTolls: false,
        polylineFormat: 'geoJSON'
        }
    })
    });

    const data = await response.json();
    console.log(data);

import { useState } from 'react';

    function DirectionsComponent() {
    const [route, setRoute] = useState(null);
    
    const getDirections = async () => {
        try {
        const response = await fetch('https://routes.codealo.com.ar/directions', {
            method: 'POST',
            headers: {
            'Content-Type': 'application/json',
            'x-api-key': 'YOUR_API_KEY'
            },
            body: JSON.stringify({
            origin: 'Plaza de Mayo, Buenos Aires, Argentina',
            destination: 'Aeropuerto de Ezeiza, Buenos Aires, Argentina',
            vehicleType: 'minivan',
            preferences: {
                avoidTolls: false,
                polylineFormat: 'geoJSON'
            }
            })
        });
        
        const data = await response.json();
        setRoute(data);
        } catch (error) {
        console.error('Error:', error);
        }
    };
    
    return (
        
        
        {route && (
            
            Distance: {route.distanceKilometers} km
            Time: {route.estimatedTimeMinutes} min
            
        )}
        
    );
    }

import { HttpClient, HttpHeaders } from '@angular/common/http';
    import { Injectable } from '@angular/core';

    @Injectable({
    providedIn: 'root'
    })
    export class DirectionsService {
    private apiUrl = 'https://routes.codealo.com.ar/directions';
    private apiKey = 'YOUR_API_KEY';
    
    constructor(private http: HttpClient) {}
    
    getDirections(origin: string, destination: string, options?: any) {
        const headers = new HttpHeaders({
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey
        });
        
        const body = {
        origin,
        destination,
        vehicleType: options?.vehicleType || 'van',
        preferences: options?.preferences || {}
        };
        
        return this.http.post(this.apiUrl, body, { headers });
    }
    }

    // En tu componente:
    // this.directionsService.getDirections(
    //   'Plaza de Mayo, Buenos Aires, Argentina',
    //   'Aeropuerto de Ezeiza, Buenos Aires, Argentina'
    // ).subscribe(data => console.log(data));

import requests

    url = "https://routes.codealo.com.ar/directions"
    headers = {
        "Content-Type": "application/json",
        "x-api-key": "YOUR_API_KEY"
    }
    payload = {
        "origin": "Plaza de Mayo, Buenos Aires, Argentina",
        "destination": "Aeropuerto de Ezeiza, Buenos Aires, Argentina",
        "vehicleType": "minivan",
        "preferences": {
            "avoidTolls": False,
            "polylineFormat": "geoJSON"
        }
    }

    response = requests.post(url, json=payload, headers=headers)
    data = response.json()
    print(data)

Response

Nota: El formato del campo polyline varía según preferences.polylineFormat. El ejemplo muestra el formato geoJSON (default).

{
    "distanceMeters": 45200,
    "distanceKilometers": 45.2,
    "estimatedTimeMinutes": 60,
    "polyline": {
        "type": "LineString",
        "coordinates": [[-58.3816, -34.6037], [-58.5396, -34.8128]]
    },
    "steps": [
        {
        "instruction": "Head north on Av. Corrientes",
        "distanceMeters": 500,
        "durationSeconds": 60,
        "startLocation": { "lat": -34.6037, "lng": -58.3816 },
        "endLocation": { "lat": -34.6087, "lng": -58.3816 }
        }
    ],
    "warnings": []
    }

💡 Ejemplo con polyline codificado: Si usás polylineFormat: "encoded" o "polyline6", el campo polyline será un string: "polyline": "encoded_polyline_string"

Atributos del Response

Campo	Tipo	Descripción
distanceMeters	number	Distancia total de la ruta en metros
distanceKilometers	number	Distancia total de la ruta en kilómetros
estimatedTimeMinutes	number	Tiempo estimado de viaje en minutos
polyline	object \| string	Representación de la ruta. El formato depende de `preferences.polylineFormat`: `"geoJSON"` (default) devuelve objeto, `"encoded"` o `"polyline6"` devuelven string codificado
polyline (geoJSON)	object	Cuando `polylineFormat: "geoJSON"` o no se especifica
polyline.type	string	Tipo GeoJSON, siempre `"LineString"`
polyline.coordinates	array	Array de coordenadas [lng, lat] para cada punto de la ruta
polyline (encoded/polyline6)	string	Cuando `polylineFormat: "encoded"` o `"polyline6"`. String codificado del algoritmo de polyline de Google Maps
steps	array	Array de pasos de navegación de la ruta (solo si `preferences.avoidSteps` no es true)
steps[].instruction	string	Instrucción de navegación para este paso
steps[].distanceMeters	number	Distancia de este paso en metros
steps[].durationSeconds	number	Duración estimada de este paso en segundos
steps[].startLocation	object	Coordenadas de inicio del paso {lat, lng}
steps[].endLocation	object	Coordenadas de fin del paso {lat, lng}
warnings	array	Array de advertencias sobre la ruta. Cada advertencia tiene `code` y `message`

⚠️ Códigos de Error

Todos los errores siguen el siguiente formato:

{
    "error": {
        "code": "ERROR_CODE",
        "message": "Descripción del error",
        "details": "Información adicional (opcional)"
    }
    }

400

Bad Request

Solicitud inválida o parámetros incorrectos

• VALIDATION_ERROR - Error de validación de parámetros
• MISSING_PARAMETERS - Faltan parámetros requeridos
• INVALID_REQUEST_ADDRESS_FIELD_IS_REQUIRED - El campo address es requerido
• ADDRESS_NOT_FOUND - Dirección no encontrada

401

Unauthorized

API Key inválida o faltante

• UNAUTHORIZED - Invalid or missing API key

404

Not Found

Recurso no encontrado

• INVALID_REQUEST_ADDRESS_FIELD_IS_NOT_FOUND - Dirección no encontrada
• NO_ROUTE_FOUND - No se encontró ruta entre los puntos

500

Internal Server Error

Error interno del servidor

• INTERNAL_SERVER_ERROR - Error del servidor

⏱️ Rate Limits

La API implementa límites de uso para garantizar un servicio estable para todos los usuarios.

Gratis

30K

requests/mes

✓ Todas las APIs
✓ Soporte por email

Pay as you go

$1.50

por 1K requests

✓ Después de 30K gratis
✓ Soporte prioritario

Alto volumen

$1.00

por 1K requests

✓ Más de 400K/mes
✓ SLA personalizado

💡 Tip: Los límites se aplican por API Key. Si necesitás mayor capacidad, contáctanos para un plan empresarial personalizado.