Minno Fraud Detector API

import requests

api_key = "demo_key_123"  # Demo API key for testing
image_path = "path/to/receipt.jpg"

url = "https://api.tryminno.com/fraud-detector/api/analyze"
headers = {"Authorization": f"Bearer {api_key}"}

with open(image_path, "rb") as image_file:
    files = {"file": image_file}
    response = requests.post(url, headers=headers, files=files)

if response.status_code == 200:
    result = response.json()
    print(f"Fraud Score: {result['normalized_score']}/100")
    print(f"Risk Level: {result['risk_level']}")
    
    if result.get('issues'):
        print("Issues detected:")
        for issue in result['issues']:
            print(f"- {issue}")
else:
    print(f"Error: {response.status_code} - {response.json()['detail']}")

// Analyze an image for fraud indicators
async function analyzeImage(imageFile) {
  const apiKey = "demo_key_123";  // Demo API key for testing
  const url = "https://api.tryminno.com/fraud-detector/api/analyze";
  
  const formData = new FormData();
  formData.append("file", imageFile);
  
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${apiKey}`
      },
      body: formData
    });
    
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`API Error: ${errorData.detail}`);
    }
    
    const result = await response.json();
    
    console.log(`Fraud Score: ${result.normalized_score}/100`);
    console.log(`Risk Level: ${result.risk_level}`);
    
    if (result.issues && result.issues.length > 0) {
      console.log("Issues detected:");
      result.issues.forEach(issue => {
        console.log(`- ${issue}`);
      });
    }
    
    return result;
  } catch (error) {
    console.error("Error analyzing image:", error);
    throw error;
  }
}

/**
 * Analyzes an image for fraud indicators using the Minno API
 * 
 * @param {File} imageFile - The image file to analyze
 * @param {string} apiKey - Your Minno API key
 * @returns {Promise} - Resolves with analysis results or rejects with error
 */
async function analyzeReceiptImage(imageFile, apiKey) {
  // Validate file type
  const validTypes = ['image/png', 'image/jpeg', 'image/jpg', 'image/heic', 'image/bmp', 'image/tiff'];
  if (!validTypes.includes(imageFile.type)) {
    throw new Error(`Unsupported file type: ${imageFile.type}. Supported types: ${validTypes.join(', ')}`);
  }
  
  // Validate file size (max 100MB)
  const MAX_SIZE = 100 * 1024 * 1024; // 100MB
  if (imageFile.size > MAX_SIZE) {
    throw new Error(`File too large: ${(imageFile.size / 1024 / 1024).toFixed(2)}MB. Maximum size is 100MB.`);
  }
  
  const url = "https://api.tryminno.com/fraud-detector/api/analyze";
  const formData = new FormData();
  formData.append("file", imageFile);
  
  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${apiKey}`
      },
      body: formData
    });
    
    // Parse response JSON
    const data = await response.json();
    
    // Handle errors
    if (!response.ok) {
      const error = new Error(data.detail || "Unknown API error");
      error.status = response.status;
      error.data = data;
      
      // Add rate limit info if available
      if (response.status === 429) {
        error.rateLimit = {
          limit: data.limit,
          reset: data.reset_at
        };
      }
      
      throw error;
    }
    
    return data;
  } catch (error) {
    if (error.status) {
      // This is an API error we've already processed
      throw error;
    } else {
      // Network or other error
      throw new Error(`Request failed: ${error.message}`);
    }
  }
}

/**
 * Renders the fraud analysis results in the UI
 * 
 * @param {Object} results - The analysis results from the API
 * @param {HTMLElement} container - The container to render results into
 */
function displayAnalysisResults(results, container) {
  // Risk level display
  let riskColor, riskIcon;
  switch(results.risk_level) {
    case "LOW":
      riskColor = "#10B981"; // Green
      riskIcon = "✅";
      break;
    case "LOW_MEDIUM":
    case "MEDIUM":
      riskColor = "#FBBF24"; // Yellow
      riskIcon = "⚠️";
      break;
    default:
      riskColor = "#EF4444"; // Red
      riskIcon = "🚨";
  }
  
  // Create HTML content
  const html = `
    

      

        
${results.normalized_score}
        
Fraud Score
      
      
      

        
${riskIcon} ${results.risk_level} RISK
        
${results.risk_description}
      
      
      

        
Issues Detected:
        ${results.issues.length > 0 
          ? `
${results.issues.map(issue => `
${issue}
`).join('')}
` 
          : '
No issues detected
'
        }
      
      
      

        
Category Breakdown:
        ${Object.entries(results.categories)
          .filter(([_, data]) => data.score > 0)
          .map(([category, data]) => `
            

              

                ${category.replace('_', ' ')}
                ${data.score}/${data.max}
              
              
${data.details}
            
          `).join('')
        }
      
      
      

        
Image Information:
        

          
Format: ${results.metadata_summary.file_format || 'Unknown'}
          
Device: ${results.metadata_summary.device || 'Unknown'}
          
GPS Data: ${results.metadata_summary.has_gps ? 'Present' : 'Not found'}
          
AI Markers: ${results.metadata_summary.ai_markers_found ? 'Detected' : 'None'}
        
      
    
  `;
  
  // Set HTML content
  container.innerHTML = html;
}

// Example usage
document.getElementById('analyzeButton').addEventListener('click', async () => {
  const fileInput = document.getElementById('imageInput');
  const resultsContainer = document.getElementById('resultsContainer');
  const loadingIndicator = document.getElementById('loadingIndicator');
  
  if (!fileInput.files || fileInput.files.length === 0) {
    alert('Please select an image to analyze');
    return;
  }
  
  const API_KEY = "demo_key_123";  // Demo API key for testing
  
  try {
    // Show loading state
    loadingIndicator.style.display = 'block';
    resultsContainer.innerHTML = '';
    
    // Analyze the image
    const results = await analyzeReceiptImage(fileInput.files[0], API_KEY);
    
    // Display results
    displayAnalysisResults(results, resultsContainer);
  } catch (error) {
    resultsContainer.innerHTML = `
      

        
Error
        
${error.message}
        ${error.rateLimit ? `
Rate limit exceeded. Resets at: ${error.rateLimit.reset}
` : ''}
      
    `;
  } finally {
    // Hide loading indicator
    loadingIndicator.style.display = 'none';
  }
});