HuntPro Logo API

Advanced AI-powered animal detection and analysis for wildlife images.

View Patent Details

Try It Out

🤖 For Agents
Status: Idle
Image preview will appear here
View Raw API Response 
Response will appear here...
Status: Idle
Image preview will appear here
View Raw API Response 
Response will appear here...

Quick Start Code Examples

Analyze Image by URL:

curl -X POST https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL \
  -H "Content-Type: application/json" \
  -d '{
    "ImageURL": "https://example.com/wildlife.jpg",
    "Key": "YOUR_API_KEY",
    "animals": ["White-tailed Deer", "Turkey"]
  }'

Analyze Image by Base64:

curl -X POST https://api.huntpro-ai.com/AnalyzeImageAdvancedBase64 \
  -H "Content-Type: application/json" \
  -d '{
    "Base64Image": "'"$(base64 -w 0 image.jpg)"'",
    "Key": "YOUR_API_KEY"
  }'

Analyze Image by URL:

import requests

url = "https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL"
payload = {
    "ImageURL": "https://example.com/wildlife.jpg",
    "Key": "YOUR_API_KEY",
    "animals": ["White-tailed Deer", "Turkey"]  # Optional filter
}

response = requests.post(url, json=payload)
data = response.json()

# Access detections
for detection in data["detections"]:
    print(f"Species: {detection['species']}")
    print(f"Confidence: {detection['confidenceLevel']}%")
    if detection.get('deerDetails'):
        print(f"Age: {detection['deerDetails']['ageCategory']}")
        print(f"Antler Points: {detection['deerDetails']['numberOfAntlerPoints']}")
    print("---")

Analyze Image by Base64:

import requests
import base64

url = "https://api.huntpro-ai.com/AnalyzeImageAdvancedBase64"

# Read and encode image
with open("wildlife.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

payload = {
    "Base64Image": image_data,
    "Key": "YOUR_API_KEY"
}

response = requests.post(url, json=payload)
data = response.json()

print(f"Found {len(data['detections'])} animals")
print(f"Daytime: {data['dayTime']}")

Analyze Image by URL:

const analyzeImage = async () => {
  const response = await fetch('https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      ImageURL: 'https://example.com/wildlife.jpg',
      Key: 'YOUR_API_KEY',
      animals: ['White-tailed Deer', 'Turkey']  // Optional filter
    })
  });

  const data = await response.json();

  // Process detections
  data.detections.forEach(detection => {
    console.log(`Species: ${detection.species}`);
    console.log(`Confidence: ${detection.confidenceLevel}%`);

    if (detection.deerDetails) {
      console.log(`Age: ${detection.deerDetails.ageCategory}`);
      console.log(`Antler Points: ${detection.deerDetails.numberOfAntlerPoints}`);
    }
  });
};

analyzeImage();

Analyze Image by Base64 (Browser):

const analyzeFromFile = async (file) => {
  // Convert file to base64
  const reader = new FileReader();

  reader.onload = async (e) => {
    const base64 = e.target.result.split(',')[1]; // Remove data URI prefix

    const response = await fetch('https://api.huntpro-ai.com/AnalyzeImageAdvancedBase64', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        Base64Image: base64,
        Key: 'YOUR_API_KEY'
      })
    });

    const data = await response.json();
    console.log(`Found ${data.detections.length} animals`);
    console.log(`Daytime: ${data.dayTime}`);
  };

  reader.readAsDataURL(file);
};

// Usage with file input
document.getElementById('fileInput').addEventListener('change', (e) => {
  analyzeFromFile(e.target.files[0]);
});

Analyze Image by URL:

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class HuntProClient
{
    private static readonly HttpClient client = new HttpClient();
    private const string ApiUrl = "https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL";

    public static async Task Main()
    {
        var request = new
        {
            ImageURL = "https://example.com/wildlife.jpg",
            Key = "YOUR_API_KEY",
            animals = new[] { "White-tailed Deer", "Turkey" } // Optional filter
        };

        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(ApiUrl, content);
        var responseBody = await response.Content.ReadAsStringAsync();

        var result = JsonSerializer.Deserialize(responseBody);

        foreach (var detection in result.detections)
        {
            Console.WriteLine($"Species: {detection.species}");
            Console.WriteLine($"Confidence: {detection.confidenceLevel}%");

            if (detection.deerDetails != null)
            {
                Console.WriteLine($"Age: {detection.deerDetails.ageCategory}");
                Console.WriteLine($"Antler Points: {detection.deerDetails.numberOfAntlerPoints}");
            }
            Console.WriteLine("---");
        }
    }
}

public class ApiResponse
{
    public Detection[] detections { get; set; }
    public bool dayTime { get; set; }
    public string make { get; set; }
}

public class Detection
{
    public string species { get; set; }
    public string gender { get; set; }
    public int confidenceLevel { get; set; }
    public DeerDetails deerDetails { get; set; }
    public BoundingBox boundingbox { get; set; }
}

public class DeerDetails
{
    public int antlerRank { get; set; }
    public int numberOfAntlerPoints { get; set; }
    public string ageCategory { get; set; }
    public string ageReasoning { get; set; }
}

public class BoundingBox
{
    public float left { get; set; }
    public float top { get; set; }
    public float width { get; set; }
    public float height { get; set; }
}

Analyze Image by Base64:

using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class HuntProBase64Client
{
    private static readonly HttpClient client = new HttpClient();
    private const string ApiUrl = "https://api.huntpro-ai.com/AnalyzeImageAdvancedBase64";

    public static async Task Main()
    {
        // Read and encode image to base64
        byte[] imageBytes = File.ReadAllBytes("wildlife.jpg");
        string base64Image = Convert.ToBase64String(imageBytes);

        var request = new
        {
            Base64Image = base64Image,
            Key = "YOUR_API_KEY"
        };

        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(ApiUrl, content);
        var responseBody = await response.Content.ReadAsStringAsync();

        var result = JsonSerializer.Deserialize(responseBody);

        Console.WriteLine($"Found {result.detections.Length} animals");
        Console.WriteLine($"Daytime: {result.dayTime}");
        Console.WriteLine($"Camera: {result.make}");
    }
}

💡 Tip: Get your production API key by contacting marketing@huntpro.app. All code examples work with both the demo key and production keys.

Use Cases

🔬

Wildlife Research

Automatically analyze thousands of trail camera images to track population dynamics, migration patterns, and species diversity. Get precise deer age classifications and antler measurements for population health studies.

  • Batch process entire camera deployments
  • Track male/female ratios across species
  • Monitor deer maturity and trophy potential
  • Identify rare or invasive species automatically
🏞️

Hunting Property Management

Make data-driven decisions about your hunting land. Identify which bucks to harvest, track turkey populations, and understand animal movement patterns across your property.

  • Identify trophy bucks by antler rank and age
  • Track gobbler vs hen ratios for turkey management
  • Monitor predator activity (coyotes, bobcats)
  • Assess property quality and carrying capacity
🌲

Conservation Monitoring

Support conservation efforts with automated wildlife monitoring. Track endangered species, monitor habitat usage, and detect human or vehicle intrusions in protected areas.

  • Detect and count multiple species simultaneously
  • Alert on human or vehicle presence in restricted zones
  • Generate reports for conservation agencies
  • Privacy-focused: no data retention for sensitive areas

Key Features

🎯 AI Reasoning
AI-driven insights and explanations for age categorization
🦌 Deer Analysis
Antler points, rank, age category, and gender classification
🦃 Turkey Gender ID
Identify Gobblers vs Hens with high accuracy
🎨 Color Detection
Pig & Bear color determination for genetic research
☀️ Day/Night Detection
Automatic scene lighting analysis
📸 Brand Extraction
Camera brand extraction
🔍 Species Filtering
Limit results to specific animals
🎯 High Accuracy
AI-powered detection with confidence scoring
📦 Bounding Boxes
Precise location coordinates for each detection
🌐 CORS Enabled
Works from any web application

API Endpoints

POST /AnalyzeImageAdvancedByURL

Analyze an image from a URL and return detected animals with bounding boxes, confidence levels, and detailed attributes.

Request Body:

{
  "ImageURL": "https://example.com/image.jpg",
  "Key": "DEMO_KEY_a7f3c8e1-4b2d-9c5f-8a3e-1d6b9f2c4e7a",
  "animals": ["White-tailed Deer", "Turkey", "Pig", "Aoudad"]  //Only animals in the list will be detected. If you send an empty array or omit this field, all supported species will be detected.
}

Response:

{
  "detections": [
    {
      "species": "White-tailed Deer",
      "gender": "Male",
      "location": 1,
      "confidenceLevel": 95,
      "antlerRank": 8,
      "boundingbox": {
        "left": 0.25,
        "top": 0.15,
        "width": 0.45,
        "height": 0.65
      },
      "deerDetails": {
        "antlerRank": 8,
        "numberOfAntlerPoints": 10,
        "ageCategory": "Mature",
        "ageReasoning": "Well-developed antlers..."
      },
      "reasoning": "Large body size, prominent antlers..."
    },
    {
      "species": "Pig",
      "gender": "Unknown",
      "location": 2,
      "confidenceLevel": 92,
      "color": "Black",
      "boundingbox": {
        "left": 0.55,
        "top": 0.40,
        "width": 0.30,
        "height": 0.45
      },
      "reasoning": "Distinctive body shape and features confirm pig identification..."
    }
  ],
  "dayTime": true,
  "make": "Reconyx"
}
POST /AnalyzeImageAdvancedBase64

Analyze an image provided as a Base64-encoded file. Same response format as URL endpoint.

Request Body:

{
  "Base64Image": "data:image/jpeg;base64,/9j/4AAQSkZJRg...",
  "Key": "your_api_key",
  "animals": ["White-tailed Deer"]  // Optional filter
}

🔒 Privacy & Data Handling

✓ No Image Storage

Images are not stored on our servers. All processing is performed in real-time.

✓ Not Used for Training

Your images are never used for model training or improvement.

✓ Encryption

All data is encrypted in transit using industry-standard HTTPS/TLS.

✓ Zero Retention

No image data is retained after the API response is returned.

Your Privacy Matters: We understand the importance of privacy for wildlife research and personal trail camera data. The HuntProAI API processes images securely and does not retain any visual data after analysis.

🤖 For AI Agents

This section provides structured, machine-readable information about the HuntProAI API for AI assistants, crawlers, and automated systems.

Structured API Information (JSON) 
{
  "service": {
    "name": "HuntProAI API",
    "version": "1.0",
    "description": "Advanced AI-powered animal detection and analysis API for wildlife images. Provides species identification, gender classification, antler analysis for deer, bounding boxes, confidence scores, and camera brand extraction. Privacy-focused: Images are not stored and are not used for training.",
    "provider": "AI Concepts LLC",
    "baseUrl": "https://api.huntpro-ai.com",
    "documentation": "https://api.huntpro-ai.com",
    "contact": {
      "email": "marketing@huntpro.app",
      "purpose": "For production API keys and support"
    }
  },
  "authentication": {
    "type": "API Key",
    "location": "Request body",
    "parameter": "Key",
    "demo_key": "DEMO_KEY_a7f3c8e1-4b2d-9c5f-8a3e-1d6b9f2c4e7a",
    "note": "Contact marketing@huntpro.app for production keys"
  },
  "endpoints": [
    {
      "path": "/AnalyzeImageAdvancedByURL",
      "method": "POST",
      "description": "Analyze an image from a URL and return detected animals with detailed attributes",
      "contentType": "application/json",
      "requestSchema": {
        "ImageURL": {
          "type": "string",
          "format": "uri",
          "required": true,
          "description": "URL of the image to analyze(jpeg, webp, png)"
        },
        "Key": {
          "type": "string",
          "required": true,
          "description": "Your API key"
        },
        "animals": {
          "type": "array",
          "items": "string",
          "required": false,
          "description": "Optional species filter. Only specified animals will be detected. Empty array or omit for all species.",
          "examples": ["White-tailed Deer", "Turkey", "Pig", "Aoudad"]
        }
      },
      "responseSchema": {
        "detections": {
          "type": "array",
          "description": "Array of detected animals",
          "items": {
            "species": "string",
            "gender": "string",
            "location": "integer",
            "confidenceLevel": "integer (0-100)",
            "color": "string (Present only for pig species - for genetics research)",
            "boundingbox": {
              "left": "float (0-1, normalized)",
              "top": "float (0-1, normalized)",
              "width": "float (0-1, normalized)",
              "height": "float (0-1, normalized)"
            },
            "deerDetails": {
              "description": "Present only for deer species",
              "antlerRank": "integer",
              "numberOfAntlerPoints": "integer",
              "ageCategory": "string (Young/Mature/Trophy)",
              "ageReasoning": "string (AI explanation)"
            },
            "reasoning": "string (AI explanation for classification)"
          }
        },
        "dayTime": {
          "type": "boolean",
          "description": "True if daytime, false if nighttime"
        },
        "make": {
          "type": "string",
          "description": "Camera brand extracted from image metadata"
        }
      }
    },
    {
      "path": "/AnalyzeImageAdvancedBase64",
      "method": "POST",
      "description": "Analyze an image provided as Base64-encoded data. Returns same format as URL endpoint.",
      "contentType": "application/json",
      "requestSchema": {
        "Base64Image": {
          "type": "string",
          "required": true,
          "description": "Base64-encoded image data with data URI prefix (e.g., data:image/jpeg;base64,...)"
        },
        "Key": {
          "type": "string",
          "required": true,
          "description": "Your API key"
        },
        "animals": {
          "type": "array",
          "items": "string",
          "required": false,
          "description": "Optional species filter"
        }
      }
    }
  ],
  "features": [
    "AI-driven reasoning and explanations for classifications",
    "Deer antler analysis (points, rank)",
    "Deer age categorization",
    "Turkey gender identification (Gobblers vs Hens)",
    "Pig & Bear color detection for genetic research",
    "Gender classification",
    "Day/night detection",
    "Camera brand extraction from EXIF data",
    "Species filtering",
    "High accuracy with confidence scoring",
    "Precise bounding boxes (normalized coordinates)",
    "CORS enabled for web applications"
  ],
  "supportedSpecies": [
    "Aoudad",
    "Axis",
    "Black Bear",
    "Black Bird",
    "Black Buck",
    "Boat",
    "Bobcat",
    "Brown Bear",
    "Chipmunk",
    "Coyote",
    "Cow",
    "Dog",
    "Elk",
    "Gray Squirrel",
    "Mountain Lion",
    "Moose",
    "Person",
    "Pig",
    "Rabbit",
    "Raccoon",
    "Spotted Skunk",
    "Turkey",
    "Turtles",
    "Vehicle",
    "White-tailed Deer",
    "Woodrat",
    "Zebra",
    "And more - contact for full list"
  ],
  "technicalDetails": {
    "cors": "Enabled",
    "rateLimit": "Contact for details",
    "imageFormats": ["JPEG", "JPG", "PNG", "WEBP"],
    "maxImageSize": "Contact for details",
    "coordinateSystem": "Normalized (0-1) relative to image dimensions"
  },
  "dataHandling": {
    "imageStorage": "Images are not stored on our servers",
    "trainingData": "Images are not used for model training or improvement",
    "encryption": "All data is encrypted in transit using industry-standard HTTPS/TLS",
    "dataRetention": "No image data is retained after API response is returned"
  },
  "usageExample": {
    "curl": "curl -X POST https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL -H 'Content-Type: application/json' -d '{\"ImageURL\":\"https://example.com/deer.jpg\",\"Key\":\"DEMO_KEY_a7f3c8e1-4b2d-9c5f-8a3e-1d6b9f2c4e7a\",\"animals\":[\"White-tailed Deer\"]}'",
    "javascript": "fetch('https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ImageURL: 'https://example.com/deer.jpg', Key: 'YOUR_API_KEY', animals: ['White-tailed Deer'] }) })",
    "python": "import requests\nresponse = requests.post('https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL', json={'ImageURL': 'https://example.com/deer.jpg', 'Key': 'YOUR_API_KEY', 'animals': ['White-tailed Deer']})"
  },
  "openApiSpec": "https://api.huntpro-ai.com/openapi.json",
  "lastUpdated": "2026-01-19"
}
OpenAI Tool Definition (Function Calling) 
[
  {
    "type": "function",
    "function": {
      "name": "huntpro_analyze_image_advanced_by_url",
      "description": "Analyze a trail-cam or wildlife image by URL and return detections (animals, counts, confidence, bounding boxes, deer antler details, pig/bear colors, turkey gender when applicable).",
      "parameters": {
        "type": "object",
        "properties": {
          "key": {
            "type": "string",
            "description": "Your HuntPro API key (contact marketing@huntpro.app for production keys)."
          },
          "imageUrl": {
            "type": "string",
            "description": "Publicly accessible image URL (jpeg/jpg/png/webp)."
          },
          "animals": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Optional array of species to filter (e.g., ['White-tailed Deer', 'Turkey']). If omitted or empty, all supported species are detected."
          }
        },
        "required": ["key", "imageUrl"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "huntpro_analyze_image_advanced_base64",
      "description": "Analyze a trail-cam or wildlife image provided as base64 and return detections (animals, counts, confidence, bounding boxes, deer antler details, pig/bear colors, turkey gender when applicable).",
      "parameters": {
        "type": "object",
        "properties": {
          "key": {
            "type": "string",
            "description": "Your HuntPro API key (contact marketing@huntpro.app for production keys)."
          },
          "base64Image": {
            "type": "string",
            "description": "Base64-encoded image data (raw base64 string without data URI prefix)."
          },
          "animals": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Optional array of species to filter (e.g., ['White-tailed Deer', 'Turkey']). If omitted or empty, all supported species are detected."
          }
        },
        "required": ["key", "base64Image"]
      }
    }
  }
]

This JSON schema is compatible with OpenAI's function calling format and can be used by AI assistants to integrate with the HuntProAI API. Map these function parameters to the actual API endpoints: /AnalyzeImageAdvancedByURL and /AnalyzeImageAdvancedBase64.

Claude Tool Definition (Anthropic) 
[
  {
    "name": "huntpro_analyze_image_by_url",
    "description": "Analyze a trail-cam or wildlife image from a URL and return detailed detections including species identification, animal counts, confidence scores, bounding boxes, deer antler analysis (points, rank, age), pig/bear color detection, and turkey gender identification (Gobblers vs Hens). Privacy-focused: images are not stored or used for training.",
    "input_schema": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "Your HuntPro API key. Contact marketing@huntpro.app for production keys."
        },
        "image_url": {
          "type": "string",
          "description": "Publicly accessible URL of the image to analyze. Supported formats: JPEG, JPG, PNG, WEBP."
        },
        "animals": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Optional array of species names to filter detections. Examples: 'White-tailed Deer', 'Turkey', 'Pig', 'Black Bear'. If omitted or empty, all 27+ supported species are detected."
        }
      },
      "required": ["key", "image_url"]
    }
  },
  {
    "name": "huntpro_analyze_image_by_base64",
    "description": "Analyze a trail-cam or wildlife image from base64-encoded data and return detailed detections including species identification, animal counts, confidence scores, bounding boxes, deer antler analysis (points, rank, age), pig/bear color detection, and turkey gender identification (Gobblers vs Hens). Privacy-focused: images are not stored or used for training.",
    "input_schema": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "description": "Your HuntPro API key. Contact marketing@huntpro.app for production keys."
        },
        "base64_image": {
          "type": "string",
          "description": "Base64-encoded image data. Should be raw base64 string without data URI prefix (no 'data:image/jpeg;base64,' prefix)."
        },
        "animals": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Optional array of species names to filter detections. Examples: 'White-tailed Deer', 'Turkey', 'Pig', 'Black Bear'. If omitted or empty, all 27+ supported species are detected."
        }
      },
      "required": ["key", "base64_image"]
    }
  }
]

Implementation Note: To use these tools with Claude, make POST requests to https://api.huntpro-ai.com/AnalyzeImageAdvancedByURL or https://api.huntpro-ai.com/AnalyzeImageAdvancedBase64 with the following request body mapping: 

// For URL analysis:
{
  "ImageURL": image_url,    // from tool input
  "Key": key,               // from tool input
  "animals": animals || []  // from tool input (optional)
}

// For Base64 analysis:
{
  "Base64Image": base64_image,  // from tool input
  "Key": key,                    // from tool input
  "animals": animals || []       // from tool input (optional)
}

📋 Additional Resources for AI Agents

  • OpenAPI Specification: openapi.json (Full API schema in OpenAPI 3.0 format)
  • JSON-LD: Structured data embedded in page head for search engines and crawlers
  • Human Documentation: Complete interactive documentation above
  • Contact: marketing@huntpro.app for production keys and support

Contact Us

To obtain a production key or for a custom AI, contact us at the email below.

📧 marketing@huntpro.app