Interactive API Explorer

Experience the Neolens API hands-on with our interactive documentation. Test endpoints, upload images, and see real AI analysis results without writing code.

🎯 Quick Start Guide

1. Authentication Setup

Before using the interactive explorer, you'll need an API key:

# Your API key format
neolens_live_abcd1234efgh5678ijkl9012

Getting your API key:

Visit neolens.ai/dashboard (fictional)
Navigate to "API Keys" section
Click "Generate New Key"
Copy and save your key securely

2. First Interactive Request

Interactive API Tester

Note: This is a documentation mockup. In a real implementation, this would be a functional API testing interface.

API Key

Image file

Confidence threshold (0.75)

Modality

Model version

Verbosity

Region of interest

Mode: Simulation (no network)

📚 Interactive Documentation Features

Live Code Examples

Each endpoint includes runnable examples in multiple languages. Use the interactive generator below to produce ready‑to‑run code for uploading an image to the Neolens API with your parameters:

Tip: Replace YOUR_API_KEY with a valid key and pick your preferred language.

Fallback (static tabs)

If JavaScript is disabled, use one of these copy‑paste examples:

Python
JavaScript
cURL
PHP
Ruby

# Python example
import requests

url = "https://api.neolens.ai/v1/analyze"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"image": open("chest_xray.jpg", "rb")}
data = {"confidence_threshold": 0.75, "modality": "auto-detect"}

resp = requests.post(url, headers=headers, files=files, data=data)
resp.raise_for_status()
result = resp.json()
print(f"Analysis complete: {result['data']['findings']}")

// Node.js example
import fs from "node:fs";
import fetch from "node-fetch";
import FormData from "form-data";

const url = "https://api.neolens.ai/v1/analyze";
const form = new FormData();
form.append("image", fs.createReadStream("chest_xray.jpg"));
form.append("confidence_threshold", "0.75");
form.append("modality", "auto-detect");

const resp = await fetch(url, {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY" },
  body: form
});
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
const result = await resp.json();
console.log("Findings:", result.data.findings);

# cURL example
curl -X POST "https://api.neolens.ai/v1/analyze" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "image=@chest_xray.jpg" \
  -F "confidence_threshold=0.75" \
  -F "modality=auto-detect"

<?php
// PHP example (requires ext-curl)
$ch = curl_init("https://api.neolens.ai/v1/analyze");
$post = [
  "image" => new CURLFile("chest_xray.jpg"),
  "confidence_threshold" => "0.75",
  "modality" => "auto-detect"
];
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => $post,
  CURLOPT_HTTPHEADER => ["Authorization: Bearer YOUR_API_KEY"],
  CURLOPT_RETURNTRANSFER => true
]);
$resp = curl_exec($ch);
if ($resp === false) { throw new Exception(curl_error($ch)); }
curl_close($ch);
$result = json_decode($resp, true);
print_r($result["data"]["findings"]);

# Ruby example
require "net/http"
require "uri"
require "json"

uri = URI.parse("https://api.neolens.ai/v1/analyze")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

form_data = [
  ["image", File.open("chest_xray.jpg")],
  ["confidence_threshold", "0.75"],
  ["modality", "auto-detect"]
]
request.set_form form_data, "multipart/form-data"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
result = JSON.parse(res.body)
puts result.dig("data", "findings")

Response Visualization

Interactive response viewer with syntax highlighting and expandable sections:

Response Explorer

{ } object · 3 keys

status: "success"

processing_time: "8.3s"

data object · 1 keys

findings array · 1 items

findings[0] object · 3 keys

label: "pulmonary_nodule"

confidence: 0.87

bounding_box array · 4 items

bounding_box[0]: 245

bounding_box[1]: 156

bounding_box[2]: 32

bounding_box[3]: 28

🧪 Interactive Tutorials

Tutorial 1: Your First AI Analysis

Goal: Upload an image and get AI analysis results

Estimated time: 5 minutes

Steps to Complete

Step 1: Prepare Your Image

✅ Download sample image
✅ Ensure image is < 10MB
✅ Supported formats: DICOM (.dcm), JPEG (.jpg), PNG (.png)

Step 2: Authentication

✅ Enter your API key in the field above
✅ Test connection with "Ping API" button

Step 3: Upload and Analyze

✅ Select your image file
✅ Keep default settings (confidence: 0.75)
✅ Click "Send Request"

Step 4: Interpret Results

✅ Review the findings array
✅ Check confidence scores
✅ Read clinical recommendations

Tutorial 2: Batch Processing

Goal: Process multiple images efficiently

Estimated time: 10 minutes

Progress: 0/0 — 0%

Tutorial 3: Advanced Configuration

Goal: Customize AI analysis parameters

Estimated time: 15 minutes

Sensitivity (0.8)

Model version

Analysis depth

Region of interest

enabled auto-detect

Output options

include_heatmap include_measurements uncertainty_estimation generate_report

{
  "sensitivity": 0.8,
  "model_version": "v3.2.1",
  "analysis_depth": "deep",
  "roi": {
    "enabled": true,
    "auto_detect": false,
    "custom_roi": [
      100,
      50,
      400,
      300
    ]
  },
  "output": {
    "include_heatmap": true,
    "include_measurements": true,
    "uncertainty_estimation": true,
    "generate_report": false
  }
}

🔧 Developer Tools

API Schema Validator

Request Validator (Live)

Request JSON

Response Mock Generator

Mock Response Generator (Live)

Scenario

Confidence Range

Number of Findings

Modality

Processing Time (s)

// Click "Generate Mock"

Code Snippet Generator

Language Code Snippet Generator

Choose language:

Features to include: Error handling Response parsing Retry logic Caching Progress indicators File upload validation

import requests

url = "https://api.neolens.ai/v1/analyze"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"image": open("chest_xray.jpg", "rb")}
data = {"confidence_threshold": 0.75, "modality": "auto-detect"}

resp = requests.post(url, headers=headers, files=files, data=data)
resp.raise_for_status()
print(resp.json())

📊 Real-time API Status

Current System Status

All Systems Operational

Service	Status	Response Time	Uptime
Authentication	🟢 Healthy	95ms	99.98%
Image Analysis	🟢 Healthy	8.2s avg	99.95%
Report Generation	🟢 Healthy	2.1s avg	99.97%
Documentation	🟢 Healthy	1.2s avg	99.99%

Queue Status: 3 requests pending, ~15s estimated wait

Last Updated: 2 minutes ago | View Detailed Status

Performance Metrics

Live Performance Dashboard

Requests/minute: ████████░░ 240 RPM (80% of capacity)
Success Rate:    ██████████ 97.8% (Last 24h)
Avg Response:    ████████░░ 8.3s (Target: <15s)

Geographic Performance:

🇺🇸 North America: 180ms avg
🇪🇺 Europe: 220ms avg
🇯🇵 Asia-Pacific: 280ms avg

🎓 Interactive Learning Path

Beginner Track

API Basics (10 min) - Authentication and first request
Understanding Responses (15 min) - Interpreting AI results
Error Handling (10 min) - Common issues and solutions

Intermediate Track

Configuration Options (20 min) - Customizing AI parameters
Batch Processing (15 min) - Handling multiple images
Integration Patterns (25 min) - Best practices for production

Advanced Track

Performance Optimization (30 min) - Scaling and efficiency
Custom Workflows (25 min) - Building specialized pipelines
Monitoring & Analytics (20 min) - Production deployment

Progress Tracking:

✅ Completed: 3/9 modules
🎯 Current: Module 4 - Configuration Options
⏱️ Estimated completion: 2.5 hours remaining

💡 Tips for Success

Getting the Most from Interactive API

Best Practices

Start with sample images to understand response format
Test with different confidence thresholds to see impact
Use the response validator to check your integration
Save successful configurations as reusable profiles

Common Pitfalls

Don't test with real patient data (use synthetic samples)
Large images (>5MB) will have longer processing times
Very low confidence thresholds may produce many false positives

Pro Tips

Use the "Copy as cURL" feature for quick testing
Bookmark frequently used endpoint configurations
Try the batch processor for multiple test images
Use mock responses during development to avoid rate limits

Interactive API Benefits

Zero setup: No installation or configuration required
Real-time testing: See actual API responses immediately
Learning by doing: Hands-on experience with all features
Code generation: Get working examples in your preferred language
Performance insights: Monitor response times and success rates

🎯 Quick Start Guide​

1. Authentication Setup​

2. First Interactive Request​

Interactive API Tester​

📚 Interactive Documentation Features​

Live Code Examples​

Response Visualization​

Response Explorer​

🧪 Interactive Tutorials​

Tutorial 1: Your First AI Analysis​

Steps to Complete​

Step 1: Prepare Your Image​

Step 2: Authentication​

Step 3: Upload and Analyze​

Step 4: Interpret Results​

Tutorial 2: Batch Processing​

Tutorial 3: Advanced Configuration​

🔧 Developer Tools​

API Schema Validator​

Request Validator (Live)​

Response Mock Generator​

Mock Response Generator (Live)​

Code Snippet Generator​

Language Code Snippet Generator

📊 Real-time API Status​

Current System Status​

All Systems Operational​

Performance Metrics​

Live Performance Dashboard​

🎓 Interactive Learning Path​

Beginner Track​

Intermediate Track​

Advanced Track​

💡 Tips for Success​

Getting the Most from Interactive API​

Best Practices​

Common Pitfalls​

Pro Tips​

🔗 Related Resources​