Code Examples

Basic Search

cURL

# Dates are optional — they default to 90/93 days from today
curl -H "X-API-KEY: your_api_key_here" \
  "{{API_BASE_URL}}/v1/accommodations?provider=booking&address=Paris"

JavaScript

const API_KEY = process.env.API22_API_KEY;
const BASE_URL = '{{API_BASE_URL}}/v1';

function formatDate(daysFromNow) {
  const date = new Date();
  date.setDate(date.getDate() + daysFromNow);
  const mm = String(date.getMonth() + 1).padStart(2, '0');
  const dd = String(date.getDate()).padStart(2, '0');
  const yyyy = date.getFullYear();
  return `${mm}/${dd}/${yyyy}`;
}

async function searchAccommodations(provider, address, checkin, checkout) {
  const params = new URLSearchParams({
    provider,
    address,
    checkin: checkin || formatDate(90),
    checkout: checkout || formatDate(93),
  });

  const response = await fetch(`${BASE_URL}/accommodations?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

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

  return (await response.json()).results;
}

// Dates default to 90/93 days from today if omitted
const results = await searchAccommodations('booking', 'Paris');

Python

import requests
import os
from datetime import datetime, timedelta

API_KEY = os.getenv('API22_API_KEY')
BASE_URL = '{{API_BASE_URL}}/v1'

def format_date(days_from_now):
    date = datetime.now() + timedelta(days=days_from_now)
    return date.strftime('%m/%d/%Y')

def search_accommodations(provider, address, checkin=None, checkout=None):
    response = requests.get(
        f'{BASE_URL}/accommodations',
        headers={'X-API-KEY': API_KEY},
        params={
            'provider': provider,
            'address': address,
            'checkin': checkin or format_date(90),
            'checkout': checkout or format_date(93),
        },
    )
    response.raise_for_status()
    return response.json()['results']

results = search_accommodations('booking', 'Paris')

Search by Coordinates

JavaScript

async function searchByLocation(provider, lat, lng) {
  const params = new URLSearchParams({
    provider,
    lat: lat.toString(),
    lng: lng.toString(),
  });

  const response = await fetch(`${BASE_URL}/accommodations?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  return (await response.json()).results;
}

const results = await searchByLocation('booking', 48.8584, 2.2945);

Python

def search_by_location(provider, lat, lng):
    response = requests.get(
        f'{BASE_URL}/accommodations',
        headers={'X-API-KEY': API_KEY},
        params={'provider': provider, 'lat': lat, 'lng': lng},
    )
    response.raise_for_status()
    return response.json()['results']

results = search_by_location('booking', 48.8584, 2.2945)

Search by Bounding Box

Ideal for map-based UIs — pass the viewport corners to search a visible area.

cURL

curl -H "X-API-KEY: your_api_key_here" \
  "{{API_BASE_URL}}/v1/accommodations?provider=booking&nelat=48.90&nelng=2.42&swlat=48.80&swlng=2.25"

JavaScript

async function searchByBoundingBox(provider, nelat, nelng, swlat, swlng) {
  const params = new URLSearchParams({
    provider,
    nelat: nelat.toString(),
    nelng: nelng.toString(),
    swlat: swlat.toString(),
    swlng: swlng.toString(),
  });

  const response = await fetch(`${BASE_URL}/accommodations?${params}`, {
    headers: { 'X-API-KEY': API_KEY },
  });

  return (await response.json()).results;
}

// Central Paris viewport
const results = await searchByBoundingBox('booking', 48.90, 2.42, 48.80, 2.25);

Python

def search_by_bounding_box(provider, nelat, nelng, swlat, swlng):
    response = requests.get(
        f'{BASE_URL}/accommodations',
        headers={'X-API-KEY': API_KEY},
        params={
            'provider': provider,
            'nelat': nelat,
            'nelng': nelng,
            'swlat': swlat,
            'swlng': swlng,
        },
    )
    response.raise_for_status()
    return response.json()['results']

# Central Paris viewport
results = search_by_bounding_box('booking', 48.90, 2.42, 48.80, 2.25)

Advanced Filters

JavaScript

const results = await searchAccommodations('booking', 'New York City');

// With filters
const params = new URLSearchParams({
  provider: 'booking',
  address: 'New York City',
  checkin: formatDate(90),
  checkout: formatDate(94),
  adults: '2',
  children: '1',
  minguestrating: '8.0',
  max: '200', // per-night price in USD
});

const response = await fetch(`${BASE_URL}/accommodations?${params}`, {
  headers: { 'X-API-KEY': API_KEY },
});
const data = await response.json();

Python

results = search_accommodations(
    'booking',
    address='New York City',
    checkin=format_date(90),
    checkout=format_date(94),
)

# With filters
response = requests.get(
    f'{BASE_URL}/accommodations',
    headers={'X-API-KEY': API_KEY},
    params={
        'provider': 'booking',
        'address': 'New York City',
        'adults': 2,
        'children': 1,
        'minguestrating': 8.0,
        'max': 200,  # per-night price in USD
    },
)

Error Handling and Retries

JavaScript

class API22Client {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = '{{API_BASE_URL}}/v1';
  }

  async request(endpoint, params = {}, maxRetries = 3) {
    const url = new URL(`${this.baseUrl}${endpoint}`);
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null) {
        url.searchParams.append(key, value.toString());
      }
    });

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      const response = await fetch(url, {
        headers: { 'X-API-KEY': this.apiKey },
      });

      // Rate limit — back off and retry
      if (response.status === 429) {
        const waitTime = Math.pow(2, attempt) * 1000;
        await new Promise((r) => setTimeout(r, waitTime));
        continue;
      }

      if (!response.ok) {
        const error = await response.json();
        throw new Error(`${error.code}: ${error.message}`);
      }

      return await response.json();
    }

    throw new Error('Max retries exceeded');
  }

  async searchAccommodations(provider, params) {
    return this.request('/accommodations', { provider, ...params });
  }
}

const client = new API22Client(process.env.API22_API_KEY);
const results = await client.searchAccommodations('booking', { address: 'Paris' });

Python

import requests
import time

class API22Client:
    def __init__(self, api_key):
        self.base_url = '{{API_BASE_URL}}/v1'
        self.session = requests.Session()
        self.session.headers.update({'X-API-KEY': api_key})

    def request(self, endpoint, params=None, max_retries=3):
        url = f'{self.base_url}{endpoint}'

        for attempt in range(max_retries):
            response = self.session.get(url, params=params)

            # Rate limit — back off and retry
            if response.status_code == 429:
                time.sleep(2 ** attempt)
                continue

            if not response.ok:
                data = response.json()
                raise Exception(f'{data["code"]}: {data["message"]}')

            return response.json()

        raise Exception('Max retries exceeded')

    def search_accommodations(self, provider, **params):
        return self.request('/accommodations', {'provider': provider, **params})

client = API22Client(os.getenv('API22_API_KEY'))
results = client.search_accommodations('booking', address='Paris')