Criminal Records API for Developers

<?php
// Replace with your actual API credentials
$apiKey = 'your_api_key_here';
$apiSecret = 'your_api_secret_here';

// Search parameters
$params = [
    'first_name' => 'John',
    'last_name' => 'Smith',
    'state' => 'CA',
    'limit' => 100
];

// Initialize cURL
$ch = curl_init('https://unlimitedcriminalchecks.com/api-2.0/search.php?' . http_build_query($params));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: ' . $apiKey,
    'X-API-Secret: ' . $apiSecret
]);

// Execute request
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

// Parse JSON response
$data = json_decode($response, true);

// Handle response
if ($httpCode === 200 && $data['success']) {
    echo "Found {$data['results']['total']} total records\n";
    echo "Credits remaining: {$data['credits']['remaining']}\n\n";
    
    // Process results
    foreach ($data['results']['sor']['records'] as $record) {
        echo "{$record['NAME']} - {$record['CITY']}, {$record['STATE']}\n";
    }
} else {
    echo "Error: {$data['message']}\n";
}
?>

import requests

# Replace with your actual API credentials
api_key = 'your_api_key_here'
api_secret = 'your_api_secret_here'

# API endpoint
url = 'https://unlimitedcriminalchecks.com/api-2.0/search.php'

# Headers with authentication
headers = {
    'X-API-Key': api_key,
    'X-API-Secret': api_secret
}

# Search parameters
params = {
    'first_name': 'John',
    'last_name': 'Smith',
    'state': 'CA',
    'limit': 100
}

# Make API request
response = requests.get(url, headers=headers, params=params)
data = response.json()

# Handle response
if response.status_code == 200 and data['success']:
    print(f"Found {data['results']['total']} total records")
    print(f"Credits remaining: {data['credits']['remaining']}\n")
    
    # Process results
    for record in data['results']['sor']['records']:
        print(f"{record['NAME']} - {record['CITY']}, {record['STATE']}")
else:
    print(f"Error: {data['message']}")

// Replace with your actual API credentials
const apiKey = 'your_api_key_here';
const apiSecret = 'your_api_secret_here';

// Build query string
const params = new URLSearchParams({
    first_name: 'John',
    last_name: 'Smith',
    state: 'CA',
    limit: 100
});

// Make API request
fetch(`https://unlimitedcriminalchecks.com/api-2.0/search.php?${params}`, {
    method: 'GET',
    headers: {
        'X-API-Key': apiKey,
        'X-API-Secret': apiSecret
    }
})
.then(response => response.json())
.then(data => {
    if (data.success) {
        console.log(`Found ${data.results.total} total records`);
        console.log(`Credits remaining: ${data.credits.remaining}`);
        
        // Process results
        data.results.sor.records.forEach(record => {
            console.log(`${record.NAME} - ${record.CITY}, ${record.STATE}`);
        });
    } else {
        console.error(`Error: ${data.message}`);
    }
})
.catch(error => {
    console.error('Request failed:', error);
});

const axios = require('axios');

// Replace with your actual API credentials
const apiKey = 'your_api_key_here';
const apiSecret = 'your_api_secret_here';

// API configuration
const config = {
    method: 'get',
    url: 'https://unlimitedcriminalchecks.com/api-2.0/search.php',
    headers: {
        'X-API-Key': apiKey,
        'X-API-Secret': apiSecret
    },
    params: {
        first_name: 'John',
        last_name: 'Smith',
        state: 'CA',
        limit: 100
    },
    timeout: 30000
};

// Make API request
axios(config)
    .then(response => {
        const data = response.data;
        
        if (data.success) {
            console.log(`Found ${data.results.total} total records`);
            console.log(`Credits remaining: ${data.credits.remaining}\n`);
            
            // Process results by type
            ['sor','doc','arrest','court'].forEach(type => {
                if (data.results[type]?.records?.length) {
                    console.log(`\n${type.toUpperCase()} Records:`);
                    data.results[type].records.forEach(r => {
                        console.log(`  ${r.NAME} - ${r.CITY}, ${r.STATE}`);
                    });
                }
            });
        } else {
            console.error(`Error: ${data.message}`);
        }
    })
    .catch(error => {
        console.error('Request failed:', error.message);
    });

require 'net/http'
require 'uri'
require 'json'

# Replace with your actual API credentials
api_key    = 'your_api_key_here'
api_secret = 'your_api_secret_here'

# Build request URL
uri = URI('https://unlimitedcriminalchecks.com/api-2.0/search.php')
uri.query = URI.encode_www_form(
  first_name: 'John',
  last_name:  'Smith',
  state:      'CA',
  limit:      100
)

# Create HTTP request
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl     = true
http.read_timeout = 30
http.open_timeout = 10

request = Net::HTTP::Get.new(uri)
request['X-API-Key']    = api_key
request['X-API-Secret'] = api_secret

# Execute request
response = http.request(request)
data     = JSON.parse(response.body)

# Handle response
if response.code.to_i == 200 && data['success']
  puts "Found #{data['results']['total']} total records"
  puts "Credits remaining: #{data['credits']['remaining']}\n\n"

  # Process SOR records
  (data['results']['sor']['records'] || []).each do |rec|
    puts "#{rec['NAME']} - #{rec['CITY']}, #{rec['STATE']}"
  end
else
  puts "Error: #{data['message']}"
end

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

class CriminalRecordsApi
{
    private static readonly HttpClient client = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(30)
    };

    static async Task Main()
    {
        string apiKey    = "your_api_key_here";
        string apiSecret = "your_api_secret_here";

        // Build query string
        var query = HttpUtility.ParseQueryString(string.Empty);
        query["first_name"] = "John";
        query["last_name"]  = "Smith";
        query["state"]      = "CA";
        query["limit"]      = "100";

        string url = $"https://unlimitedcriminalchecks.com/api-2.0/search.php?{query}";

        // Create request with auth headers
        using var request = new HttpRequestMessage(HttpMethod.Get, url);
        request.Headers.Add("X-API-Key",    apiKey);
        request.Headers.Add("X-API-Secret", apiSecret);

        // Execute request
        var response = await client.SendAsync(request);
        string body  = await response.Content.ReadAsStringAsync();
        var data     = JsonDocument.Parse(body).RootElement;

        if (response.IsSuccessStatusCode && data.GetProperty("success").GetBoolean())
        {
            int total = data.GetProperty("results").GetProperty("total").GetInt32();
            Console.WriteLine($"Found {total} total records");

            // Iterate SOR records
            var sorRecords = data.GetProperty("results").GetProperty("sor").GetProperty("records");
            foreach (var rec in sorRecords.EnumerateArray())
            {
                string name  = rec.TryGetProperty("NAME",  out var n) ? n.GetString() : "";
                string city  = rec.TryGetProperty("CITY",  out var c) ? c.GetString() : "";
                string state = rec.TryGetProperty("STATE", out var s) ? s.GetString() : "";
                Console.WriteLine($"  {name} - {city}, {state}");
            }
        }
        else
        {
            string msg = data.TryGetProperty("message", out var m) ? m.GetString() : "Unknown error";
            Console.WriteLine($"Error: {msg}");
        }
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

const (
	apiKey    = "your_api_key_here"
	apiSecret = "your_api_secret_here"
)

type APIResponse struct {
	Success bool `json:"success"`
	Results struct {
		Total int `json:"total"`
		SOR   struct {
			Count   int                      `json:"count"`
			Records []map[string]interface{} `json:"records"`
		} `json:"sor"`
	} `json:"results"`
	Credits struct {
		Used      int `json:"used"`
		Remaining int `json:"remaining"`
	} `json:"credits"`
	Message string `json:"message"`
}

func main() {
	client := &http.Client{Timeout: 30 * time.Second}

	// Build URL with query parameters
	params := url.Values{}
	params.Set("first_name", "John")
	params.Set("last_name",  "Smith")
	params.Set("state",      "CA")
	params.Set("limit",      "100")
	endpoint := "https://unlimitedcriminalchecks.com/api-2.0/search.php?" + params.Encode()

	req, _ := http.NewRequest("GET", endpoint, nil)
	req.Header.Set("X-API-Key",    apiKey)
	req.Header.Set("X-API-Secret", apiSecret)

	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("Request error: %v\n", err)
		return
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	var data APIResponse
	json.Unmarshal(body, &data)

	if data.Success {
		fmt.Printf("Found %d total records\n", data.Results.Total)
		for _, rec := range data.Results.SOR.Records {
			fmt.Printf("  %v - %v, %v\n", rec["NAME"], rec["CITY"], rec["STATE"])
		}
	} else {
		fmt.Printf("Error: %s\n", data.Message)
	}
}