API Documentation

X-API-Token: your_api_token_here

GET /api/AnalyticsApi/ping?apiToken=your_api_token_here

https://analytics.boats/api/AnalyticsApi

{
    "success": boolean,    // Indicates if the request was successful
    "message": string,     // Status message or error description
    "data": object|null    // Response data (if applicable)
}

{
    "success": false,
    "message": "Invalid or missing API token",
    "data": null
}

const axios = require('axios');

const API_TOKEN = 'your_api_token_here';
const BASE_URL = 'https://analytics.boats/api/AnalyticsApi';

// Phase 1: Track an event
async function trackEvent(ip, userAgent, keyword) {
    const response = await axios.post(`${BASE_URL}/track`, {
        ip, userAgent, keyword, referrer: 'https://yoursite.com'
    }, {
        headers: { 'X-API-Token': API_TOKEN, 'Content-Type': 'application/json' }
    });
    return response.data.data.trackId; // Save this UUID for phase 2
}

// Phase 2: Update with results
async function updateTrackResult(trackId, result) {
    const response = await axios.put(`${BASE_URL}/track/${trackId}`, result, {
        headers: { 'X-API-Token': API_TOKEN, 'Content-Type': 'application/json' }
    });
    return response.data;
}

// Example: Two-phase tracking workflow
async function performTracking() {
    // Phase 1: Initial track
    const trackId = await trackEvent('192.168.1.1', 'Mozilla/5.0', 'product_search');
    console.log('Track started, trackId:', trackId);

    // ... perform your page load / scraping here ...
    const startTime = Date.now();
    // simulate page load
    const loadTime = (Date.now() - startTime) / 1000;

    // Phase 2: Update with results
    const result = await updateTrackResult(trackId, {
        captchaSolved: true,
        pageLoadTime: loadTime,
        pageContent: 'Product: Widget - $29.99'
    });
    console.log('Track updated:', result);
}

performTracking();

import requests
import time

API_TOKEN = 'your_api_token_here'
BASE_URL = 'https://analytics.boats/api/AnalyticsApi'
HEADERS = {'X-API-Token': API_TOKEN, 'Content-Type': 'application/json'}

# Phase 1: Track event
def track_event(ip, user_agent, keyword, referrer=''):
    payload = {'ip': ip, 'userAgent': user_agent, 'keyword': keyword, 'referrer': referrer}
    response = requests.post(f'{BASE_URL}/track', json=payload, headers=HEADERS)
    return response.json()['data']['trackId']

# Phase 2: Update with results
def update_track(track_id, captcha_solved=None, page_load_time=None, page_content=None, error_log=None):
    payload = {}
    if captcha_solved is not None: payload['captchaSolved'] = captcha_solved
    if page_load_time is not None: payload['pageLoadTime'] = page_load_time
    if page_content is not None: payload['pageContent'] = page_content
    if error_log is not None: payload['errorLog'] = error_log
    response = requests.put(f'{BASE_URL}/track/{track_id}', json=payload, headers=HEADERS)
    return response.json()

# Example: Two-phase tracking
track_id = track_event('192.168.1.1', 'Mozilla/5.0', 'product_search')
print(f'Track started, trackId: {track_id}')

# Perform your scraping here...
start_time = time.time()
# ... scraping logic ...
load_time = time.time() - start_time

# Update with results
result = update_track(track_id, captcha_solved=True, page_load_time=load_time, page_content='Product: Widget')
print(f'Track updated: {result}')

<?php
$apiToken = 'your_api_token_here';
$baseUrl = 'https://analytics.boats/api/AnalyticsApi';
$headers = ['X-API-Token: ' . $apiToken, 'Content-Type: application/json'];

// Phase 1: Track event
function trackEvent($ip, $userAgent, $keyword, $referrer = '') {
    global $baseUrl, $headers;
    $data = ['ip' => $ip, 'userAgent' => $userAgent, 'keyword' => $keyword, 'referrer' => $referrer];
    $ch = curl_init("$baseUrl/track");
    curl_setopt_array($ch, [CURLOPT_POST => true, CURLOPT_POSTFIELDS => json_encode($data),
        CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => $headers]);
    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $response['data']['trackId'];
}

// Phase 2: Update with results
function updateTrack($trackId, $data) {
    global $baseUrl, $headers;
    $ch = curl_init("$baseUrl/track/$trackId");
    curl_setopt_array($ch, [CURLOPT_CUSTOMREQUEST => 'PUT', CURLOPT_POSTFIELDS => json_encode($data),
        CURLOPT_RETURNTRANSFER => true, CURLOPT_HTTPHEADER => $headers]);
    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $response;
}

// Example: Two-phase tracking
$trackId = trackEvent('192.168.1.1', 'Mozilla/5.0', 'form_submit');
echo "Track started, trackId: $trackId\n";

// Perform scraping here...
$startTime = microtime(true);
// ... scraping logic ...
$loadTime = microtime(true) - $startTime;

// Update with results
$result = updateTrack($trackId, ['captchaSolved' => true, 'pageLoadTime' => $loadTime, 'pageContent' => 'Content...']);
print_r($result);
?>

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

public class AnalyticsClient
{
    private readonly HttpClient _client;
    private readonly string _baseUrl = "https://analytics.boats/api/AnalyticsApi";

    public AnalyticsClient(string apiToken)
    {
        _client = new HttpClient();
        _client.DefaultRequestHeaders.Add("X-API-Token", apiToken);
    }

    // Phase 1: Track event
    public async Task<string> TrackEventAsync(string ip, string userAgent, string keyword)
    {
        var payload = new { ip, userAgent, keyword, referrer = "" };
        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
        var response = await _client.PostAsync($"{_baseUrl}/track", content);
        var json = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
        return json.RootElement.GetProperty("data").GetProperty("trackId").GetString();
    }

    // Phase 2: Update with results
    public async Task<string> UpdateTrackAsync(string trackId, bool? captchaSolved = null,
        double? pageLoadTime = null, string pageContent = null, string errorLog = null)
    {
        var payload = new Dictionary<string, object>();
        if (captchaSolved.HasValue) payload["captchaSolved"] = captchaSolved.Value;
        if (pageLoadTime.HasValue) payload["pageLoadTime"] = pageLoadTime.Value;
        if (pageContent != null) payload["pageContent"] = pageContent;
        if (errorLog != null) payload["errorLog"] = errorLog;

        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
        var response = await _client.PutAsync($"{_baseUrl}/track/{trackId}", content);
        return await response.Content.ReadAsStringAsync();
    }
}

// Example: Two-phase tracking
var client = new AnalyticsClient("your_api_token_here");
var trackId = await client.TrackEventAsync("192.168.1.1", "Mozilla/5.0", "purchase");
Console.WriteLine($"Track started, trackId: {trackId}");

// Perform scraping here...
var stopwatch = Stopwatch.StartNew();
// ... scraping logic ...
stopwatch.Stop();

// Update with results
var result = await client.UpdateTrackAsync(trackId, captchaSolved: true,
    pageLoadTime: stopwatch.Elapsed.TotalSeconds, pageContent: "Product details...");