Country Data API proporciona información detallada sobre +200 países diferentes

Descripción general

El endpoint /v1/zipcodes/region devuelve todos los códigos postales de los países dentro de una región geográfica específica (ej. Europa, África, Américas). Es ideal para aplicaciones que necesitan trabajar con códigos postales de múltiples países en un área geográfica.

Endpoint

GET https://api.countrydataapi.com/v1/zipcodes/region

Autenticación

Incluye tu clave API como parámetro de consulta:

?apikey=tu-clave-api

Tu clave API es como una contraseña, mantenla segura. Obtén tu clave desde el panel de cuenta.

Parámetros de consulta

Parámetro	Tipo	Requerido	Descripción
`apikey`	string	Sí	Tu clave de autenticación API
`region`	string	Sí	Nombre de la región que se busca (ej. "Africa", "Europe")
`lang`	string	No	Código de idioma para la respuesta (predeterminado: `en`)
`limitToken`	number	No	Máximo de tokens a gastar en esta petición (predeterminado: `1000`)

Regiones disponibles

Africa
Americas
Asia
Europe
Oceania

Idiomas soportados

en - Inglés (predeterminado)
es - Español
pt - Portugués
fr - Francés
de - Alemán
it - Italiano

Uso de tokens

Cada código postal devuelto costará 1 token.

Importante: Las regiones contienen muchos países con miles de códigos postales. Usa limitToken para controlar costos efectivamente.

Formato de respuesta

Respuesta exitosa

[
  {
    "id": "8dd25479-067a-43b0-ac4a-8e7faf2bcaf",
    "country_name": "Algeria",
    "state_names": [
      {
        "id": "8dd25479-067a-43b0-ac4a-8e7faf2bcad",
        "name": "Oran",
        "postal_code": [
          "31004",
          "31016",
          "31019",
          "31020"
        ]
      }
    ]
  },
  {
    "id": "9ae35480-178b-54c1-bd5b-9f8gbf3cdeg",
    "country_name": "Morocco",
    "state_names": [
      {
        "id": "9ae35480-178b-54c1-bd5b-9f8gbf3cdeh",
        "name": "Casablanca-Settat",
        "postal_code": [
          "20000",
          "20100",
          "20200"
        ]
      }
    ]
  }
]

Campos de respuesta

Campo	Tipo	Descripción
`id`	string	Identificador único del país
`country_name`	string	Nombre del país en el idioma solicitado
`state_names`	array	Array de objetos de estado que contienen códigos postales
`state_names[].id`	string	Identificador único del estado
`state_names[].name`	string	Nombre del estado/provincia
`state_names[].postal_code`	array	Array de códigos postales para este estado

Respuesta de error

{
  "success": false,
  "error": {
    "code": "MISSING_PARAMETER",
    "message": "Required parameter 'region' is missing"
  }
}

Consulta la documentación de códigos de error para todos los códigos de error posibles.

Ejemplos de código

cURL

# Obtener códigos postales de África
curl -X GET "https://api.countrydataapi.com/v1/zipcodes/region?apikey=tu-clave-api&region=Africa&lang=en&limitToken=500"

# Obtener códigos postales de Europa
curl -X GET "https://api.countrydataapi.com/v1/zipcodes/region?apikey=tu-clave-api&region=Europe&lang=en&limitToken=1000"

# Obtener códigos postales de Américas en español
curl -X GET "https://api.countrydataapi.com/v1/zipcodes/region?apikey=tu-clave-api&region=Americas&lang=es&limitToken=500"

JavaScript (Fetch)

const API_KEY = 'tu-clave-api';
const BASE_URL = 'https://api.countrydataapi.com/v1';

async function getZipcodesByRegion(region, limitToken = 1000) {
  try {
    const params = new URLSearchParams({
      apikey: API_KEY,
      region: region,
      lang: 'en',
      limitToken: limitToken.toString()
    });

    const response = await fetch(`${BASE_URL}/zipcodes/region?${params}`);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching zipcodes by region:', error);
    throw error;
  }
}

// Ejemplos de uso
const africaZipcodes = await getZipcodesByRegion('Africa', 500);
console.log(`Encontrados ${africaZipcodes.length} países en África`);

const europeZipcodes = await getZipcodesByRegion('Europe', 1000);
console.log(`Encontrados ${europeZipcodes.length} países en Europa`);

JavaScript (Axios)

import axios from 'axios';

const API_KEY = 'tu-clave-api';
const BASE_URL = 'https://api.countrydataapi.com/v1';

async function getZipcodesByRegion(region, limitToken = 1000) {
  try {
    const response = await axios.get(`${BASE_URL}/zipcodes/region`, {
      params: {
        apikey: API_KEY,
        region: region,
        lang: 'en',
        limitToken: limitToken
      }
    });

    return response.data;
  } catch (error) {
    if (error.response) {
      console.error('API Error:', error.response.data);
      throw new Error(error.response.data.error?.message || 'API Error');
    } else {
      console.error('Network Error:', error.message);
      throw error;
    }
  }
}

// Uso
const asiaData = await getZipcodesByRegion('Asia', 500);
const totalCountries = asiaData.length;
const totalStates = asiaData.reduce((sum, c) => sum + c.state_names.length, 0);
console.log(`Asia: ${totalCountries} países, ${totalStates} estados/provincias`);

React

import { useState, useEffect } from 'react';

const API_KEY = 'tu-clave-api';
const BASE_URL = 'https://api.countrydataapi.com/v1';

const REGIONS = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'];

function useRegionZipcodes(region, limitToken = 1000) {
  const [data, setData] = useState([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  useEffect(() => {
    if (!region) {
      setData([]);
      return;
    }

    async function fetchZipcodes() {
      try {
        setLoading(true);
        setError(null);

        const params = new URLSearchParams({
          apikey: API_KEY,
          region: region,
          lang: 'en',
          limitToken: limitToken.toString()
        });

        const response = await fetch(`${BASE_URL}/zipcodes/region?${params}`);

        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }

        const result = await response.json();
        setData(result);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchZipcodes();
  }, [region, limitToken]);

  return { data, loading, error };
}

// Ejemplo de componente
function RegionZipcodeExplorer() {
  const [selectedRegion, setSelectedRegion] = useState('');
  const { data, loading, error } = useRegionZipcodes(selectedRegion, 500);

  const stats = {
    countries: data.length,
    states: data.reduce((sum, c) => sum + c.state_names.length, 0),
    zipcodes: data.reduce((sum, c) =>
      sum + c.state_names.reduce((s, st) => s + st.postal_code.length, 0),
      0
    )
  };

  return (
    <div>
      <h2>Explorar Códigos Postales por Región</h2>

      <select
        value={selectedRegion}
        onChange={(e) => setSelectedRegion(e.target.value)}
      >
        <option value="">Selecciona una región...</option>
        {REGIONS.map(region => (
          <option key={region} value={region}>{region}</option>
        ))}
      </select>

      {loading && <p>Cargando códigos postales...</p>}
      {error && <p style={{ color: 'red' }}>Error: {error}</p>}

      {data.length > 0 && (
        <div>
          <h3>{selectedRegion}</h3>
          <p>
            Países: {stats.countries} |
            Estados: {stats.states} |
            Códigos Postales: {stats.zipcodes}
          </p>

          <div style={{ maxHeight: '400px', overflow: 'auto' }}>
            {data.map(country => (
              <details key={country.id}>
                <summary>
                  <strong>{country.country_name}</strong>
                  ({country.state_names.length} estados)
                </summary>
                <div style={{ paddingLeft: '20px' }}>
                  {country.state_names.map(state => (
                    <div key={state.id} style={{ margin: '5px 0' }}>
                      <strong>{state.name}:</strong>
                      <span style={{ fontSize: '0.9em', color: '#666' }}>
                        {' '}{state.postal_code.slice(0, 5).join(', ')}
                        {state.postal_code.length > 5 && '...'}
                      </span>
                    </div>
                  ))}
                </div>
              </details>
            ))}
          </div>
        </div>
      )}
    </div>
  );
}

export default RegionZipcodeExplorer;

Vue 3

<script setup>
import { ref, watch, computed } from 'vue';

const API_KEY = 'tu-clave-api';
const BASE_URL = 'https://api.countrydataapi.com/v1';

const REGIONS = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'];

const selectedRegion = ref('');
const regionData = ref([]);
const loading = ref(false);
const error = ref(null);

const stats = computed(() => ({
  countries: regionData.value.length,
  states: regionData.value.reduce((sum, c) => sum + c.state_names.length, 0),
  zipcodes: regionData.value.reduce((sum, c) =>
    sum + c.state_names.reduce((s, st) => s + st.postal_code.length, 0),
    0
  )
}));

watch(selectedRegion, async (newRegion) => {
  if (!newRegion) {
    regionData.value = [];
    return;
  }

  try {
    loading.value = true;
    error.value = null;

    const params = new URLSearchParams({
      apikey: API_KEY,
      region: newRegion,
      lang: 'en',
      limitToken: '500'
    });

    const response = await fetch(`${BASE_URL}/zipcodes/region?${params}`);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    regionData.value = await response.json();
  } catch (err) {
    error.value = err.message;
  } finally {
    loading.value = false;
  }
});
</script>

<template>
  <div>
    <h2>Explorar Códigos Postales por Región</h2>

    <select v-model="selectedRegion">
      <option value="">Selecciona una región...</option>
      <option v-for="region in REGIONS" :key="region" :value="region">
        {{ region }}
      </option>
    </select>

    <div v-if="loading">Cargando códigos postales...</div>
    <div v-else-if="error" style="color: red;">Error: {{ error }}</div>

    <div v-else-if="regionData.length > 0">
      <h3>{{ selectedRegion }}</h3>
      <p>
        Países: {{ stats.countries }} |
        Estados: {{ stats.states }} |
        Códigos Postales: {{ stats.zipcodes }}
      </p>

      <div style="max-height: 400px; overflow: auto;">
        <details v-for="country in regionData" :key="country.id">
          <summary>
            <strong>{{ country.country_name }}</strong>
            ({{ country.state_names.length }} estados)
          </summary>
          <div style="padding-left: 20px;">
            <div
              v-for="state in country.state_names"
              :key="state.id"
              style="margin: 5px 0;"
            >
              <strong>{{ state.name }}:</strong>
              <span style="font-size: 0.9em; color: #666;">
                {{ state.postal_code.slice(0, 5).join(', ') }}
                <span v-if="state.postal_code.length > 5">...</span>
              </span>
            </div>
          </div>
        </details>
      </div>
    </div>
  </div>
</template>

Angular

// zipcode.service.ts
import { Injectable } from '@angular/core';
import { HttpClient, HttpParams } from '@angular/common/http';
import { Observable } from 'rxjs';

interface State {
  id: string;
  name: string;
  postal_code: string[];
}

interface CountryZipcode {
  id: string;
  country_name: string;
  state_names: State[];
}

@Injectable({
  providedIn: 'root'
})
export class ZipcodeService {
  private readonly API_KEY = 'tu-clave-api';
  private readonly BASE_URL = 'https://api.countrydataapi.com/v1';

  constructor(private http: HttpClient) {}

  getZipcodesByRegion(
    region: string,
    limitToken: number = 1000
  ): Observable<CountryZipcode[]> {
    const params = new HttpParams()
      .set('apikey', this.API_KEY)
      .set('region', region)
      .set('lang', 'en')
      .set('limitToken', limitToken.toString());

    return this.http.get<CountryZipcode[]>(
      `${this.BASE_URL}/zipcodes/region`,
      { params }
    );
  }
}

// region-zipcode-explorer.component.ts
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { ZipcodeService } from './zipcode.service';

interface Stats {
  countries: number;
  states: number;
  zipcodes: number;
}

@Component({
  selector: 'app-region-zipcode-explorer',
  standalone: true,
  imports: [CommonModule, FormsModule],
  template: `
    <div>
      <h2>Explorar Códigos Postales por Región</h2>

      <select [(ngModel)]="selectedRegion" (ngModelChange)="onRegionChange()">
        <option value="">Selecciona una región...</option>
        <option *ngFor="let region of regions" [value]="region">
          {{ region }}
        </option>
      </select>

      <div *ngIf="loading">Cargando códigos postales...</div>
      <div *ngIf="error" style="color: red;">Error: {{ error }}</div>

      <div *ngIf="regionData.length > 0 && !loading">
        <h3>{{ selectedRegion }}</h3>
        <p>
          Países: {{ stats.countries }} |
          Estados: {{ stats.states }} |
          Códigos Postales: {{ stats.zipcodes }}
        </p>

        <div style="max-height: 400px; overflow: auto;">
          <details *ngFor="let country of regionData">
            <summary>
              <strong>{{ country.country_name }}</strong>
              ({{ country.state_names.length }} estados)
            </summary>
            <div style="padding-left: 20px;">
              <div
                *ngFor="let state of country.state_names"
                style="margin: 5px 0;"
              >
                <strong>{{ state.name }}:</strong>
                <span style="font-size: 0.9em; color: #666;">
                  {{ state.postal_code.slice(0, 5).join(', ') }}
                  <span *ngIf="state.postal_code.length > 5">...</span>
                </span>
              </div>
            </div>
          </details>
        </div>
      </div>
    </div>
  `
})
export class RegionZipcodeExplorerComponent {
  regions = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'];
  selectedRegion = '';
  regionData: any[] = [];
  loading = false;
  error: string | null = null;

  get stats(): Stats {
    return {
      countries: this.regionData.length,
      states: this.regionData.reduce((sum, c) => sum + c.state_names.length, 0),
      zipcodes: this.regionData.reduce((sum, c) =>
        sum + c.state_names.reduce((s: number, st: any) => s + st.postal_code.length, 0),
        0
      )
    };
  }

  constructor(private zipcodeService: ZipcodeService) {}

  onRegionChange() {
    if (!this.selectedRegion) {
      this.regionData = [];
      return;
    }

    this.loading = true;
    this.error = null;

    this.zipcodeService.getZipcodesByRegion(this.selectedRegion, 500).subscribe({
      next: (data) => {
        this.regionData = data;
        this.loading = false;
      },
      error: (err) => {
        this.error = err.message;
        this.loading = false;
      }
    });
  }
}

PHP

<?php
$apiKey = 'tu-clave-api';
$region = 'Europe';
$limitToken = 500;

$url = "https://api.countrydataapi.com/v1/zipcodes/region?" . http_build_query([
    'apikey' => $apiKey,
    'region' => $region,
    'lang' => 'en',
    'limitToken' => $limitToken
]);

// Usando cURL
$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
        'Accept: application/json'
    ]
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$curlError = curl_error($ch);
curl_close($ch);

if ($curlError) {
    die("cURL Error: {$curlError}");
}

if ($httpCode === 200) {
    $data = json_decode($response, true);

    echo "Región: {$region}\n";
    echo "Países encontrados: " . count($data) . "\n\n";

    $totalStates = 0;
    $totalZipcodes = 0;

    foreach ($data as $country) {
        $countryStates = count($country['state_names']);
        $countryZipcodes = 0;

        foreach ($country['state_names'] as $state) {
            $countryZipcodes += count($state['postal_code']);
        }

        $totalStates += $countryStates;
        $totalZipcodes += $countryZipcodes;

        echo "  {$country['country_name']}: {$countryStates} estados, {$countryZipcodes} códigos postales\n";
    }

    echo "\nTotal: {$totalStates} estados, {$totalZipcodes} códigos postales\n";
} else {
    echo "Error: HTTP {$httpCode}\n";
    $error = json_decode($response, true);
    echo "Mensaje: " . ($error['error']['message'] ?? 'Error desconocido') . "\n";
}

// Función reutilizable
function getZipcodesByRegion($apiKey, $region, $lang = 'en', $limitToken = 1000) {
    $url = "https://api.countrydataapi.com/v1/zipcodes/region?" . http_build_query([
        'apikey' => $apiKey,
        'region' => $region,
        'lang' => $lang,
        'limitToken' => $limitToken
    ]);

    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new Exception("API Error: HTTP {$httpCode}");
    }

    return json_decode($response, true);
}

// Uso
try {
    $africaData = getZipcodesByRegion($apiKey, 'Africa', 'en', 300);
    echo "\nÁfrica tiene " . count($africaData) . " países\n";

    $americasData = getZipcodesByRegion($apiKey, 'Americas', 'es', 400);
    echo "Américas tiene " . count($americasData) . " países\n";
} catch (Exception $e) {
    echo $e->getMessage();
}
?>

Python

import requests
from typing import List, Dict, Any

API_KEY = 'tu-clave-api'
BASE_URL = 'https://api.countrydataapi.com/v1'

REGIONS = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania']

def get_zipcodes_by_region(
    region: str,
    lang: str = 'en',
    limit_token: int = 1000
) -> List[Dict[str, Any]]:
    """
    Obtener códigos postales de todos los países en una región específica.

    Args:
        region: Nombre de la región geográfica (Africa, Americas, Asia, Europe, Oceania)
        lang: Código de idioma para la respuesta
        limit_token: Máximo de tokens a gastar en esta petición

    Returns:
        Lista de países con sus estados y códigos postales
    """
    if region not in REGIONS:
        raise ValueError(f"Región inválida. Debe ser una de: {', '.join(REGIONS)}")

    try:
        response = requests.get(
            f'{BASE_URL}/zipcodes/region',
            params={
                'apikey': API_KEY,
                'region': region,
                'lang': lang,
                'limitToken': limit_token
            },
            timeout=30
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        print(f'HTTP Error: {e.response.status_code}')
        print(f'Response: {e.response.text}')
        raise
    except requests.exceptions.RequestException as e:
        print(f'Request Error: {e}')
        raise

def calculate_region_stats(data: List[Dict[str, Any]]) -> Dict[str, int]:
    """Calcular estadísticas para datos de región"""
    countries = len(data)
    states = sum(len(c['state_names']) for c in data)
    zipcodes = sum(
        len(state['postal_code'])
        for c in data
        for state in c['state_names']
    )
    return {
        'countries': countries,
        'states': states,
        'zipcodes': zipcodes
    }

# Ejemplos de uso
if __name__ == '__main__':
    # Obtener datos de África
    print("=== África ===")
    africa_data = get_zipcodes_by_region('Africa', limit_token=500)
    africa_stats = calculate_region_stats(africa_data)
    print(f"Países: {africa_stats['countries']}")
    print(f"Estados: {africa_stats['states']}")
    print(f"Códigos Postales: {africa_stats['zipcodes']}")

    # Listar países
    for country in africa_data[:5]:
        print(f"  - {country['country_name']}: {len(country['state_names'])} estados")

    # Obtener datos de Europa
    print("\n=== Europa ===")
    europe_data = get_zipcodes_by_region('Europe', limit_token=1000)
    europe_stats = calculate_region_stats(europe_data)
    print(f"Países: {europe_stats['countries']}")
    print(f"Estados: {europe_stats['states']}")
    print(f"Códigos Postales: {europe_stats['zipcodes']}")

    # Obtener datos de Américas en español
    print("\n=== Américas (Español) ===")
    americas_data = get_zipcodes_by_region('Americas', lang='es', limit_token=500)
    for country in americas_data[:3]:
        print(f"  - {country['country_name']}")

# Versión asíncrona usando aiohttp
import aiohttp
import asyncio

async def get_zipcodes_by_region_async(
    region: str,
    lang: str = 'en',
    limit_token: int = 1000
) -> List[Dict[str, Any]]:
    """Versión asíncrona usando aiohttp"""
    async with aiohttp.ClientSession() as session:
        async with session.get(
            f'{BASE_URL}/zipcodes/region',
            params={
                'apikey': API_KEY,
                'region': region,
                'lang': lang,
                'limitToken': limit_token
            }
        ) as response:
            if response.status != 200:
                text = await response.text()
                raise Exception(f'API Error: {response.status} - {text}')
            return await response.json()

# Obtener todas las regiones en paralelo
async def get_all_regions() -> Dict[str, List[Dict[str, Any]]]:
    """Obtener códigos postales de todas las regiones en paralelo"""
    tasks = [
        get_zipcodes_by_region_async(region, limit_token=200)
        for region in REGIONS
    ]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return {
        region: result
        for region, result in zip(REGIONS, results)
        if not isinstance(result, Exception)
    }

# Ejecutar async
# all_regions = asyncio.run(get_all_regions())
# for region, data in all_regions.items():
#     print(f"{region}: {len(data)} países")

Manejo de errores

Siempre implementa un manejo de errores adecuado:

async function getZipcodesWithErrorHandling(region) {
  const validRegions = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'];

  if (!validRegions.includes(region)) {
    throw new Error(`Región inválida. Debe ser una de: ${validRegions.join(', ')}`);
  }

  try {
    const response = await fetch(
      `https://api.countrydataapi.com/v1/zipcodes/region?apikey=tu-clave-api&region=${encodeURIComponent(region)}`
    );

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));

      switch (response.status) {
        case 400:
          throw new Error(errorData.error?.message || 'Parámetros de petición inválidos');
        case 401:
          throw new Error('Clave API inválida');
        case 402:
          throw new Error('Tokens insuficientes. Por favor actualiza tu plan.');
        case 404:
          throw new Error(`Región "${region}" no encontrada`);
        case 429:
          throw new Error('Límite de tasa excedido. Por favor intenta más tarde.');
        default:
          throw new Error(`HTTP error! status: ${response.status}`);
      }
    }

    const data = await response.json();

    if (!Array.isArray(data)) {
      throw new Error('Formato de respuesta inválido');
    }

    return data;
  } catch (error) {
    console.error('Error al obtener códigos postales de la región:', error.message);
    throw error;
  }
}

Códigos de error comunes

Código de Error	Descripción	Solución
`INVALID_API_KEY`	La clave API es inválida	Verifica tu clave API en el panel de cuenta
`MISSING_PARAMETER`	Falta el parámetro `region`	Incluye nombre de región válido en la petición
`REGION_NOT_FOUND`	La región no existe	Usa una región válida: Africa, Americas, Asia, Europe, Oceania
`QUOTA_EXCEEDED`	Límite diario de tokens alcanzado	Actualiza tu plan o espera el reinicio

Casos de uso

1. Dashboard de estadísticas regionales

async function getRegionalStats() {
  const regions = ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'];
  const stats = {};

  for (const region of regions) {
    const data = await getZipcodesByRegion(region, 100);
    stats[region] = {
      countries: data.length,
      states: data.reduce((sum, c) => sum + c.state_names.length, 0),
      zipcodes: data.reduce((sum, c) =>
        sum + c.state_names.reduce((s, st) => s + st.postal_code.length, 0), 0
      )
    };
  }

  return stats;
}

2. Filtrar países por región

async function getCountriesInRegion(region) {
  const data = await getZipcodesByRegion(region);

  return data.map(country => ({
    id: country.id,
    name: country.country_name,
    stateCount: country.state_names.length
  }));
}

// Uso
const europeanCountries = await getCountriesInRegion('Europe');
console.log(europeanCountries);

3. Búsqueda entre regiones

async function findPostalCodeInRegion(region, postalCode) {
  const data = await getZipcodesByRegion(region);

  for (const country of data) {
    for (const state of country.state_names) {
      if (state.postal_code.includes(postalCode)) {
        return {
          found: true,
          country: country.country_name,
          state: state.name,
          postalCode: postalCode
        };
      }
    }
  }

  return { found: false };
}

// Uso
const result = await findPostalCodeInRegion('Europe', '75001');
console.log(result); // { found: true, country: 'France', state: 'Ile-de-France', ... }

Consejos de rendimiento

Usa limitToken: Las regiones contienen muchos países; controla el tamaño de datos
Cachea por región: Los datos regionales rara vez cambian; cachea por 24+ horas
Carga progresiva: Carga una región a la vez, no todas de una vez
Peticiones paralelas: Usa async/await con Promise.all para múltiples regiones

Límites de tasa

Tier gratuito: 100 peticiones/día
Tier básico: 1,000 peticiones/día
Tier pro: 10,000 peticiones/día
Tier empresarial: Ilimitado

Consulta nuestra página de precios para más detalles.

Endpoints relacionados

GET /v1/zipcodes/all - Obtener todos los códigos postales
GET /v1/zipcodes/country - Obtener códigos postales por país
GET /v1/zipcodes/state - Obtener códigos postales por estado
GET /v1/countries/region - Obtener países por región

¿Necesitas ayuda?

Consulta nuestra documentación de códigos de error
Ve la guía de autenticación
Contacta soporte a través de tu panel de cuenta

Documentación de la API - Endpoints y Ejemplos

Buscar códigos postales por región