Getting Started with Camino AI - Quick Start Guide

Step 1: Create Account

1. Visit app.getcamino.ai
2. Click "Continue with Google" or "Continue with GitHub"
3. Authorize the application
4. You'll be redirected to your dashboard

Free Tier: New accounts automatically get 1,000 free API calls per month, forever. No credit card required.

Step 2: Get Your API Key

1. Navigate to your Dashboard
2. Scroll to "API Keys" section
3. Click "Create New API Key"
4. Add a description (e.g., "Production App")
5. Copy and save your API key securely

Security Note: Store your API key in environment variables, never commit to version control.

Step 3: Make Your First API Call

Using cURL

curl -X GET "https://api.getcamino.ai/query?query=coffee%20shops&lat=40.7589&lon=-73.9851&rank=true" \
  -H "X-API-Key: YOUR_API_KEY"

Using Python

import requests

API_KEY = "your_api_key_here"
API_URL = "https://api.getcamino.ai/query"

params = {
    "query": "coffee shops",
    "lat": 40.7589,
    "lon": -73.9851,
    "rank": True,
    "limit": 10
}

headers = {"X-API-Key": API_KEY}

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

print(f"Found {len(data['results'])} coffee shops")
for place in data['results']:
    print(f"- {place['name']} ({place['distance_km']}km away)")

Using JavaScript/Node.js

const API_KEY = "your_api_key_here";
const API_URL = "https://api.getcamino.ai/query";

const params = new URLSearchParams({
  query: "coffee shops",
  lat: 40.7589,
  lon: -73.9851,
  rank: true,
  limit: 10
});

fetch(`${API_URL}?${params}`, {
  headers: { "X-API-Key": API_KEY }
})
  .then(res => res.json())
  .then(data => {
    console.log(`Found ${data.results.length} coffee shops`);
    data.results.forEach(place => {
      console.log(`- ${place.name} (${place.distance_km}km away)`);
    });
  });

Common Query Patterns

Basic Location Search

GET /query?
  query=restaurants&
  lat=34.0522&
  lon=-118.2437&
  radius=1000&
  rank=true

Contextual Search

GET /query?
  query=quiet coffee shops good for working&
  lat=37.7749&
  lon=-122.4194&
  rank=true&
  answer=true

Proximity Search

GET /query?
  query=hotels near Golden Gate Bridge&
  lat=37.8199&
  lon=-122.4783&
  radius=2000&
  rank=true

Understanding API Responses

Standard response structure:

{
  "results": [
    {
      "name": "Location Name",
      "type": "cafe",
      "lat": 40.7614,
      "lon": -73.9776,
      "address": "123 Main St, City, State",
      "distance_km": 0.5,
      "distance_miles": 0.31,
      "tags": {
        "amenity": "cafe",
        "opening_hours": "Mo-Fr 07:00-19:00"
      }
    }
  ],
  "answer": "AI-generated summary of results...",
  "total_results": 12,
  "query_timestamp": "2025-11-23T10:30:00Z"
}

Response Fields

• results: Array of matching locations
• answer: AI-generated human-readable summary (if answer=true)
• total_results: Number of results found
• query_timestamp: When the query was processed

Next Steps

1. Explore Other Endpoints

• /relationship: Calculate distance and travel time between locations
• /route: Get turn-by-turn directions
• /context: Get AI-generated area descriptions
• /journey: Plan multi-stop trips

2. Set Up MCP Integration (Optional)

Connect Camino AI to Claude Desktop or other MCP-compatible tools:

// Add to claude_desktop_config.json
{
  "mcpServers": {
    "camino-ai": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-http",
        "https://api.getcamino.ai/mcp?caminoApiKey=YOUR_KEY"
      ]
    }
  }
}

3. Review Documentation

• Interactive API Docs - Try endpoints in your browser
• Feature Overview - Complete feature list
• vs Google Places - Feature comparison

Best Practices

• Always include coordinates: Provide lat/lon for accurate results
• Enable AI ranking: Set rank=true for relevance-sorted results
• Set appropriate radius: Urban: 500-2000m, Suburban: 2000-5000m, Rural: 10000+ m
• Use descriptive queries: "family-friendly restaurants" > "restaurants"
• Request answers for summaries: Set answer=true for human-readable descriptions
• Handle rate limits: Stay under 30 requests/minute
• Cache responses: Location data doesn't change frequently

Troubleshooting

Common Issues

401 Unauthorized

• Check API key is included in X-API-Key header
• Verify API key is active in dashboard
• Ensure no extra spaces in API key

429 Too Many Requests

• You've exceeded 30 requests/minute rate limit
• Implement exponential backoff
• Consider caching responses

Empty Results

• Try increasing radius parameter
• Verify coordinates are correct (lat/lon order)
• Use broader query terms

Slow Responses

• AI ranking adds ~200-400ms processing time
• Set rank=false if speed is critical
• Reduce limit parameter for faster responses

Example Integration: Location-Aware Chatbot

// Simple chatbot with location awareness
import OpenAI from 'openai';
import fetch from 'node-fetch';

const openai = new OpenAI();
const CAMINO_API_KEY = process.env.CAMINO_API_KEY;

async function searchLocations(query, lat, lon) {
  const params = new URLSearchParams({
    query, lat, lon, rank: true, answer: true
  });
  
  const response = await fetch(
    `https://api.getcamino.ai/query?${params}`,
    { headers: { "X-API-Key": CAMINO_API_KEY } }
  );
  
  return response.json();
}

async function chatWithLocation(userMessage, userLat, userLon) {
  // If user asks about locations, query Camino AI
  if (userMessage.toLowerCase().includes('find') ||
      userMessage.toLowerCase().includes('where')) {
    
    const locationData = await searchLocations(
      userMessage, userLat, userLon
    );
    
    return `Found ${locationData.results.length} places. ${locationData.answer}`;
  }
  
  // Otherwise, use standard ChatGPT
  const completion = await openai.chat.completions.create({
    messages: [{ role: 'user', content: userMessage }],
    model: 'gpt-4'
  });
  
  return completion.choices[0].message.content;
}

Monitoring Usage

Track your API usage in the Dashboard:

• Current month usage count
• Remaining free tier calls
• Usage history and trends
• Per-API-key breakdown