1. Get Your API Key

To use the Cortex-1 API, you'll need an API key. Contact our sales team to get started:

2. Make Your First Request

Once you have your API key, you can start making requests. Here's a simple example using cURL:

curl -X POST https://api.chatuxo.com/brain \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your_api_key_here" \
  -d '{
    "message": "What is the capital of France?"
  }'

Response:

{
  "response": "The capital of France is Paris.",
  "model": "groq",
  "timestamp": "2024-01-15T10:30:00Z"
}

3. Try Different Endpoints

Explore the various capabilities of the API:

Web Search

curl -X POST https://api.chatuxo.com/search \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your_api_key_here" \
  -d '{
    "query": "latest AI developments",
    "sources": ["brave", "bing"]
  }'

Generate Website

curl -X POST https://api.chatuxo.com/generate/website \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your_api_key_here" \
  -d '{
    "prompt": "Create a landing page for a SaaS product",
    "blueprint": "saas"
  }'

Business Tools

curl -X POST https://api.chatuxo.com/tools/seo \
  -H "Content-Type: application/json" \
  -H "X-API-Key: your_api_key_here" \
  -d '{
    "url": "https://example.com",
    "action": "audit"
  }'

4. Error Handling

The API uses standard HTTP status codes. Here are the most common responses:

• 200 OK - Request successful
• 400 Bad Request - Invalid request parameters
• 401 Unauthorized - Invalid or missing API key
• 429 Too Many Requests - Rate limit exceeded
• 500 Internal Server Error - Server error

Next Steps

Now that you've made your first requests, explore the full API documentation to discover all available endpoints and capabilities.

Create an intelligent chatbot with context awareness, conversation memory, and multi-turn interactions.

Prerequisites

• uxo API key
• Basic knowledge of JavaScript or Python
• Node.js or Python 3.7+ installed

Step 1: Basic Chat Implementation

Start with a simple chat function that sends messages to the brain endpoint:

// JavaScript Example
async function chat(message, conversationHistory = []) {
  const response = await fetch('https://api.chatuxo.com/brain', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: message,
      context: conversationHistory.join('\n')
    })
  });
  
  const data = await response.json();
  return data.response;
}

Step 2: Maintain Conversation Context

Store conversation history to maintain context across multiple turns:

class Chatbot {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.history = [];
  }
  
  async send(userMessage) {
    // Add user message to history
    this.history.push(`User: ${userMessage}`);
    
    // Send to API with context
    const response = await fetch('https://api.chatuxo.com/brain', {
      method: 'POST',
      headers: {
        'X-API-Key': this.apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        message: userMessage,
        context: this.history.slice(-10).join('\n') // Last 10 messages
      })
    });
    
    const data = await response.json();
    
    // Add bot response to history
    this.history.push(`Assistant: ${data.response}`);
    
    return data.response;
  }
  
  clearHistory() {
    this.history = [];
  }
}

Step 3: Add Web Interface

Create a simple HTML interface for your chatbot:

<div class="chat-container">
  <div id="messages"></div>
  <input id="user-input" placeholder="Type a message...">
  <button onclick="sendMessage()">Send</button>
</div>

<script>
const bot = new Chatbot('your_api_key_here');

async function sendMessage() {
  const input = document.getElementById('user-input');
  const message = input.value;
  
  // Display user message
  addMessage('user', message);
  
  // Get bot response
  const response = await bot.send(message);
  
  // Display bot response
  addMessage('bot', response);
  
  input.value = '';
}

function addMessage(sender, text) {
  const messagesDiv = document.getElementById('messages');
  const messageEl = document.createElement('div');
  messageEl.className = `message ${sender}`;
  messageEl.textContent = text;
  messagesDiv.appendChild(messageEl);
}
</script>

Best Practices

• Limit context to last 10-15 messages to avoid token limits
• Implement typing indicators for better UX
• Add error handling for API failures
• Store conversation history in localStorage for persistence
• Implement rate limiting on the client side

Automate comprehensive web research using multiple search sources and AI-powered analysis.

Step 1: Multi-Source Search

Query multiple search engines simultaneously for comprehensive results:

async function researchTopic(topic) {
  const response = await fetch('https://api.chatuxo.com/search', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      query: topic,
      sources: ['brave', 'bing', 'tavily', 'duckduckgo']
    })
  });
  
  const results = await response.json();
  return results;
}

Step 2: Competitor Analysis

Use the audit endpoint to analyze competitor websites:

async function analyzeCompetitor(url) {
  const response = await fetch('https://api.chatuxo.com/audit', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: url,
      checks: ['seo', 'performance', 'accessibility', 'content']
    })
  });
  
  return await response.json();
}

// Analyze multiple competitors
const competitors = [
  'https://competitor1.com',
  'https://competitor2.com',
  'https://competitor3.com'
];

const analyses = await Promise.all(
  competitors.map(url => analyzeCompetitor(url))
);

console.log('Competitor Analysis:', analyses);

Step 3: Prospect Research

Deep dive into prospect companies using the prospect endpoint:

async function researchProspect(companyName) {
  const response = await fetch('https://api.chatuxo.com/prospect', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      company: companyName,
      depth: 'comprehensive'
    })
  });
  
  const data = await response.json();
  
  return {
    company: data.company_info,
    financials: data.financial_data,
    news: data.recent_news,
    employees: data.key_employees,
    technologies: data.tech_stack
  };
}

Step 4: Generate Research Report

Combine all research into a comprehensive report:

async function generateResearchReport(topic) {
  // 1. Search for information
  const searchResults = await researchTopic(topic);
  
  // 2. Analyze key websites
  const topUrls = searchResults.results.slice(0, 3).map(r => r.url);
  const audits = await Promise.all(topUrls.map(analyzeCompetitor));
  
  // 3. Generate summary with brain
  const response = await fetch('https://api.chatuxo.com/brain', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: `Create a comprehensive research report on: ${topic}`,
      context: JSON.stringify({
        search_results: searchResults,
        website_audits: audits
      })
    })
  });
  
  return await response.json();
}

Build content pipelines that generate websites, emails, and social media posts at scale.

Step 1: Generate Landing Pages

Create professional landing pages programmatically:

async function createLandingPage(productName, description) {
  const response = await fetch('https://api.chatuxo.com/generate/website', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      prompt: `Create a SaaS landing page for ${productName}: ${description}`,
      blueprint: 'saas',
      sections: ['hero', 'features', 'pricing', 'testimonials', 'cta']
    })
  });
  
  const data = await response.json();
  
  // Save to file
  const fs = require('fs');
  fs.writeFileSync(`${productName}-landing.html`, data.html);
  
  return data;
}

Step 2: Email Campaign Generator

Generate personalized email campaigns:

async function generateEmailCampaign(campaign) {
  const emails = [];
  
  for (const recipient of campaign.recipients) {
    const response = await fetch('https://api.chatuxo.com/generate/email', {
      method: 'POST',
      headers: {
        'X-API-Key': 'your_api_key_here',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        type: campaign.type, // 'promotional', 'newsletter', 'follow-up'
        recipient_name: recipient.name,
        recipient_company: recipient.company,
        personalization: recipient.metadata,
        tone: 'professional',
        include_html: true
      })
    });
    
    const email = await response.json();
    emails.push({
      to: recipient.email,
      subject: email.subject,
      html: email.html_body,
      text: email.text_body
    });
  }
  
  return emails;
}

Step 3: Social Media Content Pipeline

Create a multi-platform social media content generator:

async function createSocialContent(topic, platforms) {
  const content = {};
  
  for (const platform of platforms) {
    const response = await fetch('https://api.chatuxo.com/generate/social', {
      method: 'POST',
      headers: {
        'X-API-Key': 'your_api_key_here',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        platform: platform, // 'twitter', 'linkedin', 'instagram'
        topic: topic,
        tone: platform === 'linkedin' ? 'professional' : 'casual',
        include_hashtags: true,
        include_image_suggestions: true
      })
    });
    
    content[platform] = await response.json();
  }
  
  return content;
}

// Example usage
const socialPosts = await createSocialContent(
  'Launch of our new AI feature',
  ['twitter', 'linkedin', 'instagram']
);

console.log('Twitter:', socialPosts.twitter.post);
console.log('LinkedIn:', socialPosts.linkedin.post);
console.log('Instagram:', socialPosts.instagram.caption);

Step 4: Content Calendar Automation

Build a complete content calendar generator:

async function generateContentCalendar(month, topics) {
  const calendar = [];
  const daysInMonth = 30;
  
  for (let day = 1; day <= daysInMonth; day++) {
    const topic = topics[day % topics.length];
    
    // Generate content for each platform
    const content = await createSocialContent(topic, [
      'twitter', 'linkedin', 'instagram'
    ]);
    
    calendar.push({
      date: `2024-${month}-${day.toString().padStart(2, '0')}`,
      topic: topic,
      content: content
    });
    
    // Rate limiting
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  
  return calendar;
}

Build an automated system to find, qualify, and score potential leads.

Step 1: Lead Discovery

Find potential leads using search and prospect research:

async function findLeads(criteria) {
  // Search for companies matching criteria
  const searchQuery = `${criteria.industry} companies in ${criteria.location}`;
  
  const response = await fetch('https://api.chatuxo.com/search', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      query: searchQuery,
      sources: ['brave', 'bing']
    })
  });
  
  const results = await response.json();
  
  // Extract company websites
  const companies = results.results
    .filter(r => r.url && !r.url.includes('linkedin'))
    .slice(0, 20);
  
  return companies;
}

Step 2: Lead Enrichment

Enrich leads with detailed company information:

async function enrichLead(companyUrl) {
  const prospectData = await fetch('https://api.chatuxo.com/prospect', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: companyUrl,
      depth: 'comprehensive'
    })
  });
  
  const data = await prospectData.json();
  
  return {
    company_name: data.company_name,
    industry: data.industry,
    employee_count: data.employee_count,
    revenue_estimate: data.revenue,
    technologies: data.tech_stack,
    decision_makers: data.key_employees,
    recent_activity: data.recent_news,
    contact_info: data.contact_information
  };
}

Step 3: Lead Scoring

Score leads based on multiple criteria:

async function scoreLead(lead) {
  const response = await fetch('https://api.chatuxo.com/score', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      lead_data: lead,
      criteria: {
        industry_match: 0.3,
        company_size: 0.2,
        technology_fit: 0.25,
        budget_signals: 0.15,
        engagement: 0.1
      }
    })
  });
  
  const score = await response.json();
  
  return {
    total_score: score.total,
    grade: score.grade, // A, B, C, D
    breakdown: score.breakdown,
    recommendation: score.action_recommendation
  };
}

Step 4: Complete Lead Pipeline

Put it all together into an automated pipeline:

async function runLeadPipeline(criteria) {
  console.log('Finding leads...');
  const rawLeads = await findLeads(criteria);
  
  console.log('Enriching leads...');
  const enrichedLeads = [];
  for (const lead of rawLeads) {
    try {
      const enriched = await enrichLead(lead.url);
      enrichedLeads.push(enriched);
      
      // Rate limiting
      await new Promise(r => setTimeout(r, 2000));
    } catch (error) {
      console.error(`Failed to enrich ${lead.url}:`, error);
    }
  }
  
  console.log('Scoring leads...');
  const scoredLeads = [];
  for (const lead of enrichedLeads) {
    const score = await scoreLead(lead);
    scoredLeads.push({
      ...lead,
      score: score
    });
  }
  
  // Sort by score
  scoredLeads.sort((a, b) => b.score.total - a.score.total);
  
  // Filter high-quality leads (A and B grade)
  const qualifiedLeads = scoredLeads.filter(
    lead => ['A', 'B'].includes(lead.score.grade)
  );
  
  console.log(`Found ${qualifiedLeads.length} qualified leads`);
  return qualifiedLeads;
}

// Run the pipeline
const leads = await runLeadPipeline({
  industry: 'SaaS',
  location: 'United States',
  size: 'mid-market'
});

// Export to CSV
exportToCSV(leads, 'qualified-leads.csv');

Automate SEO audits, keyword research, and content optimization.

Step 1: Website SEO Audit

Run comprehensive SEO audits on any website:

async function seoAudit(url) {
  const response = await fetch('https://api.chatuxo.com/tools/seo', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: url,
      action: 'audit',
      checks: [
        'meta_tags',
        'headings',
        'content_quality',
        'internal_links',
        'mobile_friendly',
        'page_speed',
        'structured_data'
      ]
    })
  });
  
  const audit = await response.json();
  
  return {
    score: audit.overall_score,
    issues: audit.issues,
    recommendations: audit.recommendations,
    opportunities: audit.opportunities
  };
}

Step 2: Keyword Research

Discover high-value keywords for your content:

async function keywordResearch(topic) {
  const response = await fetch('https://api.chatuxo.com/tools/seo', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      action: 'keyword_research',
      topic: topic,
      intent: 'commercial' // or 'informational', 'transactional'
    })
  });
  
  const keywords = await response.json();
  
  return keywords.map(kw => ({
    keyword: kw.term,
    search_volume: kw.volume,
    difficulty: kw.difficulty,
    cpc: kw.cpc,
    related_terms: kw.related
  }));
}

Step 3: Content Optimization

Optimize existing content for target keywords:

async function optimizeContent(content, targetKeyword) {
  const response = await fetch('https://api.chatuxo.com/brain', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key_here',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: `Optimize this content for SEO targeting "${targetKeyword}"`,
      context: content
    })
  });
  
  const optimized = await response.json();
  
  return {
    optimized_content: optimized.response,
    keyword_density: calculateKeywordDensity(optimized.response, targetKeyword),
    meta_title: generateMetaTitle(targetKeyword),
    meta_description: generateMetaDescription(optimized.response)
  };
}

function calculateKeywordDensity(content, keyword) {
  const words = content.toLowerCase().split(/\s+/);
  const keywordCount = words.filter(w => w.includes(keyword.toLowerCase())).length;
  return ((keywordCount / words.length) * 100).toFixed(2);
}

Best Practices

• Run audits weekly to track improvement
• Focus on low-competition, high-value keywords
• Optimize for user intent, not just keyword density
• Monitor competitors' SEO strategies
• Keep content fresh with regular updates