Evaligo

Evaligo automatically generates comprehensive API documentation for every deployed flow, including request/response schemas, code examples, and an interactive testing interface.

Accessing Documentation

After deploying a flow as an API, documentation is available at:

https://api.evaligo.com/flows/{flow-id}/docs

Example:

Your Flow: Website Analyzer
Flow ID: flow_abc123xyz
Docs: https://api.evaligo.com/flows/flow_abc123xyz/docs

Documentation Features

OpenAPI/Swagger Specification

Full OpenAPI 3.0 compliant specification:

  • Request schemas (from API Input nodes)
  • Response schemas (from API Output nodes)
  • Authentication requirements
  • Error response formats
  • Endpoint metadata and descriptions

Interactive API Explorer

Test your API directly from the documentation:

  • Fill in request parameters
  • Provide authentication token
  • Send requests with one click
  • View formatted responses
  • See execution time and costs

Code Examples

Ready-to-use code snippets in multiple languages:

  • cURL
  • Python (requests)
  • JavaScript (fetch, axios)
  • Node.js
  • Ruby
  • Go
Tip
Share the documentation URL with your team or API consumers. It's always up-to-date with your latest flow configuration.

Request Documentation

Endpoint Details

POST /flows/{flow-id}/execute
POST /flows/{flow-id}/execute-async

Description: Execute the Website Analyzer flow
Authentication: Bearer token required
Content-Type: application/json

Request Schema

Generated from API Input node:

{
  "type": "object",
  "required": ["websiteUrl"],
  "properties": {
    "websiteUrl": {
      "type": "string",
      "format": "uri",
      "description": "The website URL to analyze",
      "example": "https://example.com"
    },
    "maxPages": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "default": 10,
      "description": "Maximum number of pages to crawl"
    }
  }
}

Example Request

curl -X POST 'https://api.evaligo.com/flows/flow_abc123/execute' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "websiteUrl": "https://example.com",
    "maxPages": 5
  }'

Response Documentation

Success Response

Generated from API Output node:

{
  "type": "object",
  "properties": {
    "summary": {
      "type": "string",
      "description": "AI-generated summary of website content"
    },
    "pagesAnalyzed": {
      "type": "integer",
      "description": "Number of pages successfully analyzed"
    },
    "websiteUrl": {
      "type": "string",
      "description": "The URL that was analyzed"
    },
    "executionTime": {
      "type": "string",
      "description": "Total execution time"
    }
  }
}

Example Response:
{
  "summary": "E-commerce site selling outdoor gear...",
  "pagesAnalyzed": 5,
  "websiteUrl": "https://example.com",
  "executionTime": "12.3s"
}

Error Response

{
  "error": {
    "code": "INVALID_INPUT",
    "message": "websiteUrl is required",
    "field": "websiteUrl"
  }
}

Status Codes:
  200: Success
  400: Invalid request
  401: Authentication failed
  403: Insufficient permissions
  429: Rate limit exceeded
  500: Server error
Warning
Always handle error responses in your API clients. Check the status code and error details for proper error handling.

Code Examples by Language

Python

import requests

API_KEY = "your_api_key"
FLOW_ID = "flow_abc123"

def analyze_website(url, max_pages=10):
    response = requests.post(
        f"https://api.evaligo.com/flows/{FLOW_ID}/execute",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "websiteUrl": url,
            "maxPages": max_pages
        }
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error {response.status_code}: {response.text}")

# Usage
result = analyze_website("https://example.com", max_pages=5)
print(result["summary"])

JavaScript (Node.js)

const fetch = require('node-fetch');

const API_KEY = 'your_api_key';
const FLOW_ID = 'flow_abc123';

async function analyzeWebsite(url, maxPages = 10) {
  const response = await fetch(
    `https://api.evaligo.com/flows/${FLOW_ID}/execute`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        websiteUrl: url,
        maxPages: maxPages
      })
    }
  );
  
  if (!response.ok) {
    throw new Error(`Error ${response.status}: ${await response.text()}`);
  }
  
  return await response.json();
}

// Usage
analyzeWebsite('https://example.com', 5)
  .then(result => console.log(result.summary))
  .catch(error => console.error(error));

cURL

# Synchronous execution
curl -X POST 'https://api.evaligo.com/flows/flow_abc123/execute' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "websiteUrl": "https://example.com",
    "maxPages": 5
  }'

# Asynchronous execution
curl -X POST 'https://api.evaligo.com/flows/flow_abc123/execute-async' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "websiteUrl": "https://example.com",
    "maxPages": 5
  }'

Versioning

API Versions

Each flow deployment creates a new version:

Version 1: https://api.evaligo.com/flows/flow_abc123/v1/execute
Version 2: https://api.evaligo.com/flows/flow_abc123/v2/execute
Latest:    https://api.evaligo.com/flows/flow_abc123/execute

Version Management

  • Latest version is default (no version in URL)
  • Previous versions remain accessible
  • Pin to specific version for stability
  • Deprecation notices in documentation
Tip
Use versioned endpoints in production to avoid breaking changes when you update your flow.

Rate Limits

Documented Limits

Rate limits are shown in the documentation:

Free Tier:
  - 100 requests per hour
  - 1,000 requests per day
  
Pro Tier:
  - 1,000 requests per hour
  - 50,000 requests per day
  
Enterprise:
  - Custom limits

Rate Limit Headers

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 842
X-RateLimit-Reset: 1642147200

When limit exceeded:
HTTP 429 Too Many Requests
Retry-After: 3600

Authentication

API Keys

Documentation includes authentication details:

Type: Bearer token
Header: Authorization: Bearer YOUR_API_KEY
Where to get: Account Settings → API Keys

Security:
  - Never commit API keys to version control
  - Rotate keys periodically
  - Use environment variables
  - Set up separate keys for dev/prod

Authentication Example

import os

# Good: Use environment variables
API_KEY = os.environ.get("EVALIGO_API_KEY")

# Bad: Hardcoded key
# API_KEY = "sk_live_abc123..."

Webhooks (Async Callbacks)

Webhook Configuration

{
  "websiteUrl": "https://example.com",
  "webhook": {
    "url": "https://yourapp.com/webhook",
    "headers": {
      "X-Custom-Header": "value"
    }
  }
}

When flow completes, POST to webhook:
{
  "executionId": "exec_123",
  "status": "completed",
  "results": {
    "summary": "...",
    "pagesAnalyzed": 5
  },
  "executionTime": "12.3s"
}

SDK Support

Official SDKs

Installation and usage:

# Python
pip install evaligo

# JavaScript
npm install evaligo-sdk
from evaligo import Client

client = Client(api_key="your_key")

result = client.flows.execute(
    flow_id="flow_abc123",
    input={"websiteUrl": "https://example.com"}
)

print(result.summary)

Best Practices

For API Consumers

  • Read the documentation thoroughly
  • Test with the interactive explorer first
  • Handle all error responses
  • Respect rate limits
  • Use async for long operations

For API Providers

  • Provide clear field descriptions in API Input nodes
  • Use meaningful variable names
  • Test thoroughly before sharing
  • Document any special requirements
  • Version your APIs for stability

Related Documentation

Deploying as APIs
Deploy your flows
API Authentication
Secure your endpoints
API Input & Output Nodes
Define API interface