Code Examples

Ready-to-use code examples in multiple programming languages.

C# Examples

Basic Request

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

public class BassodeClient
{
    private readonly HttpClient _httpClient;
    private const string BaseUrl = "https://api.bassode.com";

    public BassodeClient(string apiKey, string apiSecret)
    {
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("X-Api-Key", apiKey);
        _httpClient.DefaultRequestHeaders.Add("X-Api-Secret", apiSecret);
    }

    public async Task<string> GetSpeakersAsync()
    {
        var response = await _httpClient.GetAsync($"{BaseUrl}/api/speakers");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

// Usage
var client = new BassodeClient("bsk_live_xxxxxx", "your_secret");
var speakers = await client.GetSpeakersAsync();
Console.WriteLine(speakers);

Strongly Typed Client

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public class Speaker
{
    public string Id { get; set; }
    public string Brand { get; set; }
    public string Model { get; set; }
    public decimal Price { get; set; }
}

public class SpeakersResponse
{
    public List<Speaker> Speakers { get; set; }
    public Pagination Pagination { get; set; }
}

public class Pagination
{
    public int Page { get; set; }
    public int PageSize { get; set; }
    public int TotalCount { get; set; }
    public int TotalPages { get; set; }
}

public class BassodeClient
{
    private readonly HttpClient _httpClient;

    public BassodeClient(string apiKey, string apiSecret)
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://api.bassode.com")
        };
        _httpClient.DefaultRequestHeaders.Add("X-Api-Key", apiKey);
        _httpClient.DefaultRequestHeaders.Add("X-Api-Secret", apiSecret);
    }

    public async Task<SpeakersResponse> GetSpeakersAsync(
        int page = 1, 
        int pageSize = 50, 
        string brand = null)
    {
        var url = $"/api/speakers?page={page}&pageSize={pageSize}";
        if (!string.IsNullOrEmpty(brand))
            url += $"&brand={brand}";

        var response = await _httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<SpeakersResponse>(json);
    }
}

// Usage
var client = new BassodeClient("bsk_live_xxxxxx", "your_secret");
var response = await client.GetSpeakersAsync(page: 1, pageSize: 20, brand: "Klipsch");

foreach (var speaker in response.Speakers)
{
    Console.WriteLine($"{speaker.Brand} {speaker.Model} - ${speaker.Price}");
}

JavaScript Examples

Fetch API

const API_KEY = 'bsk_live_xxxxxx';
const API_SECRET = 'your_secret';
const BASE_URL = 'https://api.bassode.com';

async function getSpeakers() {
  const response = await fetch(`${BASE_URL}/api/speakers`, {
    headers: {
      'X-Api-Key': API_KEY,
      'X-Api-Secret': API_SECRET
    }
  });

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

  const data = await response.json();
  return data;
}

// Usage
getSpeakers()
  .then(data => {
    console.log('Speakers:', data.speakers);
    console.log('Total count:', data.pagination.totalCount);
  })
  .catch(error => console.error('Error:', error));

Axios

const axios = require('axios');

const bassodeClient = axios.create({
  baseURL: 'https://api.bassode.com',
  headers: {
    'X-Api-Key': 'bsk_live_xxxxxx',
    'X-Api-Secret': 'your_secret'
  }
});

// Get speakers
async function getSpeakers(params = {}) {
  try {
    const response = await bassodeClient.get('/api/speakers', { params });
    return response.data;
  } catch (error) {
    console.error('Error fetching speakers:', error.response?.data || error.message);
    throw error;
  }
}

// Usage
const speakers = await getSpeakers({ 
  brand: 'Klipsch', 
  page: 1, 
  pageSize: 20 
});

speakers.speakers.forEach(speaker => {
  console.log(`${speaker.brand} ${speaker.model} - $${speaker.price}`);
});

React Hook

import { useState, useEffect } from 'react';

const API_KEY = process.env.REACT_APP_BASSODE_API_KEY;
const API_SECRET = process.env.REACT_APP_BASSODE_API_SECRET;

function useSpeakers(filters = {}) {
  const [speakers, setSpeakers] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function fetchSpeakers() {
      try {
        setLoading(true);
        const params = new URLSearchParams(filters);
        const response = await fetch(
          `https://api.bassode.com/api/speakers?${params}`,
          {
            headers: {
              'X-Api-Key': API_KEY,
              'X-Api-Secret': API_SECRET
            }
          }
        );

        if (!response.ok) throw new Error('Failed to fetch speakers');

        const data = await response.json();
        setSpeakers(data.speakers);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchSpeakers();
  }, [JSON.stringify(filters)]);

  return { speakers, loading, error };
}

// Usage in component
function SpeakerList() {
  const { speakers, loading, error } = useSpeakers({ brand: 'Klipsch' });

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;

  return (
    <ul>
      {speakers.map(speaker => (
        <li key={speaker.id}>
          {speaker.brand} {speaker.model} - ${speaker.price}
        </li>
      ))}
    </ul>
  );
}

Python Examples

Requests Library

import requests
import os

API_KEY = os.getenv('BASSODE_API_KEY')
API_SECRET = os.getenv('BASSODE_API_SECRET')
BASE_URL = 'https://api.bassode.com'

class BassodeClient:
    def __init__(self, api_key, api_secret):
        self.session = requests.Session()
        self.session.headers.update({
            'X-Api-Key': api_key,
            'X-Api-Secret': api_secret
        })
        self.base_url = BASE_URL

    def get_speakers(self, **params):
        response = self.session.get(f'{self.base_url}/api/speakers', params=params)
        response.raise_for_status()
        return response.json()

    def get_speaker(self, speaker_id):
        response = self.session.get(f'{self.base_url}/api/speakers/{speaker_id}')
        response.raise_for_status()
        return response.json()

# Usage
client = BassodeClient(API_KEY, API_SECRET)

# Get speakers with filters
speakers_data = client.get_speakers(brand='Klipsch', page=1, pageSize=20)

for speaker in speakers_data['speakers']:
    print(f"{speaker['brand']} {speaker['model']} - ${speaker['price']}")

With Error Handling

import requests
from typing import Dict, List, Optional

class BassodeError(Exception):
    """Base exception for Bassode API errors"""
    pass

class BassodeClient:
    def __init__(self, api_key: str, api_secret: str):
        self.session = requests.Session()
        self.session.headers.update({
            'X-Api-Key': api_key,
            'X-Api-Secret': api_secret
        })
        self.base_url = 'https://api.bassode.com'

    def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
        url = f'{self.base_url}{endpoint}'
        
        try:
            response = self.session.request(method, url, **kwargs)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            error_msg = e.response.json().get('message', str(e))
            raise BassodeError(f"API Error: {error_msg}") from e
        except requests.exceptions.RequestException as e:
            raise BassodeError(f"Request failed: {str(e)}") from e

    def get_speakers(
        self, 
        page: int = 1, 
        page_size: int = 50,
        brand: Optional[str] = None,
        min_price: Optional[float] = None,
        max_price: Optional[float] = None
    ) -> Dict:
        params = {'page': page, 'pageSize': page_size}
        if brand:
            params['brand'] = brand
        if min_price is not None:
            params['minPrice'] = min_price
        if max_price is not None:
            params['maxPrice'] = max_price
            
        return self._request('GET', '/api/speakers', params=params)

# Usage with error handling
try:
    client = BassodeClient(API_KEY, API_SECRET)
    data = client.get_speakers(brand='Klipsch', min_price=400, max_price=800)
    
    print(f"Found {data['pagination']['totalCount']} speakers")
    for speaker in data['speakers']:
        print(f"  {speaker['brand']} {speaker['model']} - ${speaker['price']}")
        
except BassodeError as e:
    print(f"Error: {e}")

cURL Examples

Get Speakers

curl https://api.bassode.com/api/speakers \
  -H "X-Api-Key: bsk_live_xxxxxx" \
  -H "X-Api-Secret: your_secret"

Get Speakers with Filters

curl "https://api.bassode.com/api/speakers?brand=Klipsch&page=1&pageSize=20" \
  -H "X-Api-Key: bsk_live_xxxxxx" \
  -H "X-Api-Secret: your_secret"

Get Single Speaker

curl https://api.bassode.com/api/speakers/123 \
  -H "X-Api-Key: bsk_live_xxxxxx" \
  -H "X-Api-Secret: your_secret"

Get Recommendations (POST)

curl -X POST https://api.bassode.com/api/recommendations \
  -H "X-Api-Key: bsk_live_xxxxxx" \
  -H "X-Api-Secret: your_secret" \
  -H "Content-Type: application/json" \
  -d '{
    "budget": 1500,
    "preferences": {
      "roomSize": "medium",
      "musicGenres": ["rock", "jazz"]
    }
  }'

Environment Variables

It's best practice to store your API credentials in environment variables:

Unix/Linux/macOS

# In ~/.bashrc or ~/.zshrc
export BASSODE_API_KEY="bsk_live_xxxxxx"
export BASSODE_API_SECRET="your_secret"

# Or in .env file
echo "BASSODE_API_KEY=bsk_live_xxxxxx" > .env
echo "BASSODE_API_SECRET=your_secret" >> .env

Windows (PowerShell)

# Set for current session
$env:BASSODE_API_KEY = "bsk_live_xxxxxx"
$env:BASSODE_API_SECRET = "your_secret"

# Set permanently
[System.Environment]::SetEnvironmentVariable('BASSODE_API_KEY', 'bsk_live_xxxxxx', 'User')
[System.Environment]::SetEnvironmentVariable('BASSODE_API_SECRET', 'your_secret', 'User')

.NET (appsettings.json)

{
  "BassodeApi": {
    "ApiKey": "bsk_live_xxxxxx",
    "ApiSecret": "your_secret",
    "BaseUrl": "https://api.bassode.com"
  }
}

Error Handling Examples

JavaScript

async function getSpeakers() {
  try {
    const response = await fetch('https://api.bassode.com/api/speakers', {
      headers: {
        'X-Api-Key': API_KEY,
        'X-Api-Secret': API_SECRET
      }
    });

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

    return await response.json();
  } catch (error) {
    if (error.message.includes('401')) {
      console.error('Authentication failed. Check your API credentials.');
    } else if (error.message.includes('403')) {
      console.error('Insufficient permissions. Check your API key scopes.');
    } else if (error.message.includes('429')) {
      console.error('Rate limit exceeded. Please wait before retrying.');
    } else {
      console.error('Request failed:', error.message);
    }
    throw error;
  }
}

Next Steps

View All Endpoints → Get Your API Keys →