API Documentation

Welcome to the RobovAI Nova API. Build powerful AI agents, automate workflows, and integrate 100+ tools into your applications with a single unified interface.

Base URL: https://robovainova.onrender.com

Authentication

Currently, the API is open for public Webhook integrations in beta. For production use, please obtain an API Key.

Authorization: Bearer YOUR_API_KEY

Chat Webhook

Send messages and get AI responses. The Smart Router will automatically detect intent and execute tools if needed.

POST /webhook

          import requests url =
            "https://robovainova.onrender.com/webhook"
            payload = {
            "user_id":
            "user_123",
            "message":
            "/weather Cairo",
            "platform":
            "web" } response = requests.post(url,
            json=payload) print(response.json())
        

Parameters

Name	Type	Description
`user_id`	string	Unique identifier for the user session
`message`	string	The user's input text or command
`platform`	string	Origin platform (web, telegram, whatsapp)

Python Integration

The easiest way to integrate Nova is using our Python snippet.

          class
            NovaClient:
            def
            __init__(self, base_url):
            self.base_url = base_url

            def
            chat(self, user_id, message): resp =
            requests.post( f"{self.base_url}/webhook", json={"user_id": user_id,
            "message": message,
            "platform":
            "api"} )
            return resp.json().get("response")

            # Usage
            client = NovaClient("https://robovainova.onrender.com") reply = client.chat("user1",
            "Generate a QR code for my website")
            print(reply)
        

Error Handling

All API errors follow a consistent JSON format with HTTP status codes.

Response Format

          { "error":
            "error_type",
            "message":
            "Human-readable error description",
            "status":
            400 }
        

Common Error Codes

Status	Error Type	Description
`400`	Bad Request	Missing required parameters or invalid input
`401`	Unauthorized	Invalid or missing API key
`429`	Rate Limit	Too many requests (see rate limits below)
`500`	Server Error	Internal processing error

List Available Tools

Get a complete list of all 100+ tools available in the Nova platform.

GET /tools/list

          import requests url =
            "https://robovainova.onrender.com/tools/list"
            response = requests.get(url) tools = response.json()
            for tool
            in tools:
            print(f"{tool['name']}: {tool['description']}")
        

Response Schema

          [ { "command":
            "/weather",
            "name":
            "Weather Check",
            "description":
            "Get current weather for any city",
            "category":
            "web" }, ... ]
        

Rate Limits & Pricing

Beta Access: During the beta phase, all endpoints are free with the following limits:

Tier	Requests/Minute	Daily Limit	Price
Free (Beta)	20 requests/min	1,000 requests/day	$0
Pro	100 requests/min	10,000 requests/day	$29/month
Enterprise	Custom	Unlimited	Contact sales

Node.js SDK

Quick integration for Node.js applications.

Installation

npm install axios

Usage

          const axios =
            require('axios');

            class
            NovaClient {
            constructor(baseURL =
            'https://robovainova.onrender.com') {
            this.client = axios.create({ baseURL
            }); }

            async
            chat(userId, message, platform =
            'api') {
            const response =
            await
            this.client.post('/webhook', { user_id: userId, message: message, platform: platform });
            return response.data; }

            async
            listTools() {
            const response =
            await
            this.client.get('/tools/list'); return response.data; } }

            // Example usage
            const nova =
            new NovaClient(); nova.chat('user123', '/weather Cairo') .then(data =>
            console.log(data.response)) .catch(err => console.error(err));
        

cURL Examples

Quick testing with command-line tools.

Chat Request

          curl -X POST https://robovainova.onrender.com/webhook \ -H
            "Content-Type: application/json" \ -d
            '{ "user_id": "user_456", "message": "/search latest AI news",
              "platform": "api" }'
        

List Tools

curl -X GET https://robovainova.onrender.com/tools/list

With Authentication (Production)

          curl -X POST https://robovainova.onrender.com/webhook \ -H
            "Authorization: Bearer YOUR_API_KEY" \
            -H "Content-Type: application/json" \ -d
            '{"user_id":"user1","message":"Hello"}'
        

Telegram Bot Integration

Connect Nova to your Telegram bot in minutes.

Setup Steps

Create a bot via @BotFather and get your token
Set up a webhook pointing to Nova's endpoint
Configure environment variables
Deploy and test

Webhook Configuration

          import requests
            from telegram
            import Update, Bot
            from telegram.ext
            import Application, MessageHandler,
            filters BOT_TOKEN =
            "YOUR_TELEGRAM_BOT_TOKEN" NOVA_URL =
            "https://robovainova.onrender.com/webhook"

            async def
            handle_message(update: Update,
            context): user_id = str(update.effective_user.id) message =
            update.message.text

            # Forward to Nova
            response = requests.post(NOVA_URL, json={
            "user_id": user_id,
            "message": message,
            "platform":
            "telegram" }) reply =
            response.json().get("response",
            "Error")
            await update.message.reply_text(reply)

            # Setup
            app = Application.builder().token(BOT_TOKEN).build()
            app.add_handler(MessageHandler(filters.TEXT, handle_message))
            app.run_polling()
        

WhatsApp API Integration

Integrate Nova with WhatsApp Business API or Twilio.

Using Twilio

          from flask
            import Flask, request
            from twilio.twiml.messaging_response
            import MessagingResponse
            import requests app = Flask(__name__)
            NOVA_URL =
            "https://robovainova.onrender.com/webhook"

            @app.route("/whatsapp", methods=['POST'])
            def
            whatsapp_webhook(): incoming_msg =
            request.values.get('Body',
            '') sender = request.values.get('From', '')

            # Call Nova
            nova_response = requests.post(NOVA_URL, json={
            "user_id": sender,
            "message": incoming_msg,
            "platform":
            "whatsapp" }) reply_text =
            nova_response.json().get("response",
            "Error")

            # Send back via Twilio
            resp = MessagingResponse() resp.message(reply_text)
            return str(resp)

            if __name__ ==
            "__main__": app.run(debug=True)
        

Note: You'll need a Twilio account and WhatsApp Business API approval. For testing, use the Twilio Sandbox for WhatsApp.