{
  "apiKey": "string"
}

{
  "access_token": "dfjsdjfksdjkjfjklfjfkldfjdjkljdfklgjgjkgjkbljfkjlkfgjlkfjgfjkjhjjkhljklhjhjkhljhjhljhkjhklhgjhkjhgkljjhkjhkjhgkljhkjhgklhgjhgjhlkjgjhklgjkljgklhjkljfklhgjkhjklhjhkgljhkjjkhgjhkljhkgljhkhlgjhkjgjhklgjhklgjkhjgkljhklghfj",
  "token_type": "Bearer",
  "expires_in": 21600, //Time in seconds token will expire
  "refresh_token": "D9Hpn9283drz4X3MyxEVu4BWjKB4G0sI", //A token you can use to get a new access_token, after the initial token expires, without having to send the credentials again.
  "scope": "offline_access"
}

{
  "pageNumber": 0,
  "pageSize": 100,
  "totalPages": 1,
  "totalEvents": 2,
  "events": [
    {
      "eventId": "string",         // unique identifier
      "eventType": "LeftRoute",    // enum: LeftRoute, RejoinedRoute
      "timestamp": "2025-12-18T18:12:37Z",
      "location": {
        "lat": 40.123456,
        "lon": -74.123456
      },
      "oorDistance": 2.34,         // out‑of‑route distance in trip units
      "oorDuration": 300,          // seconds out of route (if available)
      "sequence": 1,               // order within trip
      "copilotTripId": "1731355367928",
      "parentTripId": "1731355367928",
      "externalTripId": "411706",
      "utcOffset": "-0500",        // if exposed
      "customPlaceId": "string or null" // if tied to a custom place
    }
  ]
}

{
  "pageNumber": 0,
  "pageSize": 100,
  "totalPages": 1,
  "totalEvents": 12,
  "events": [
    {
      "eventId": "string",
      "eventType": "Speed",        // See enum list above
      "timestamp": "2025-12-18T18:12:37Z",
      "location": {
        "lat": 39.104528,
        "lon": -88.546931
      },
      "heading": 268,
      "copilotTripId": "080625115811899_3",
      "parentTripId": "10313829",
      "externalTripId": "500473679",
      "driverId": "546",
      "vehicleId": "string or null",
      "utcOffset": "-0600",
      "mapVersion": "GRD_ALK.NA.2025.02.21.7.1.1",
      "appVersion": "10.28.2.351",

      // One of the following typed payloads will be populated,
      // others present as null (per “all relevant attributes even if null”).[^]
      "speedEvent": {
        "currentSpeed": 67,
        "postedSpeed": 55
      },
      "rolloverEvent": {
        "currentSpeed": 42,
        "rolloverPostedSpeed": 27,
        "rolloverPostedLat": 35.285943,
        "rolloverPostedLon": -81.187014
      },
      "restrictedRoadEvent": {
        "roadRestrictionType": "general"
      },
      "idleEvent": {
        "idleDuration": 600    // seconds
      },
      "lowBridgeEvent": {
        "bridgeHeight": null   // if returned, otherwise null
      },
      "outOfRouteEvent": {
        "eventSubtype": "LeftRoute", // or RejoinedRoute
        "oorDistance": 0.5,
        "oorDuration": 120
      },
      "weatherEvent": {
        "weatherNotificationId": "396e266d-f9c8-4852-8121-9772c1fe3ed3",
        "roadRisk": "moderate",
        "impactSummary": "visibility",
        "impactsStartPoint": "-85236207,31174661",
        "impactsEndPoint": "-85109274,31133676"
      },
      "slowdownEvent": {
        "currentSpeed": 65,
        "beforeSlowdownSpeed": 62,
        "slowdownDropSpeed": 27,
        "slowdownGridLinkId": "45671140|19",
        "slowdownLat": 32.957554,
        "slowdownLon": -96.351695
      },
      "trafficDetourEvent": {
        "initialLat": 36.060017,
        "initialLon": -79.398190,
        "minutesSaved": 34,
        "newDistanceMeters": 124506,
        "newEta": "2025-08-04T12:41:05Z",
        "response": "Accepted",
        "trafficClosureInfo": "1100452,65;-94117631,44144487|"
      },
      "hosEvent": {
        "hosCategory": 0,      // 0 Break, 1 Driving, 2 OnDuty, 3 Cycle
        "timeRemainingMinutes": 15
      },
      "suddenElevationEvent": {
        "startLat": 38.567498,
        "startLon": -79.090300,
        "gridId": 1763596,
        "linkId": 153,
        "startSpeedKph": 72,
        "elevationType": "Uphill",
        "gradePercent": 20
      }
    }
  ]
}

curl -X POST "https://api.trimblemaps.com/identity/v2/token" \
  -H "Content-Type: application/json" \
  -d '{"apiKey": "YOUR_API_KEY_HERE"}'

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI...",
  "token_type": "Bearer",
  "expires_in": 21600,
  "refresh_token": "D9Hpn9283drz4X3MyxEVu4BWjKB4G0sI",
  "scope": "offline_access"
}

curl -X POST "https://routereporterservice.trimblemaps.com/api/v2/search" \
  -H "Content-Type: application/json" \
  -H "Authorization: bearer YOUR_ACCESS_TOKEN_HERE" \
  -d '{
    "startDate": "2025-12-17T00:00:00",
    "endDate": "2025-12-18T00:00:00",
    "pageNumber": 0
  }'

{
  "responseMessage": "Success",
  "results": [
    {
      "tripID": "1731355367928",
      "externalTripID": "411706",
      "vehicleID": "39462118",
      "vehicleName": "TestVehicle",
      "status": "Completed",
      "plannedDistance": 6.57,
      "actualDistance": 6.34,
      "startTime": "2024-11-11T20:02:47",
      "endTime": "2024-11-12T02:15:47"
    }
  ],
  "pageNumber": 0,
  "totalPages": 5,
  "totalTrips": 47
}

curl -X POST "https://routereporterservice.trimblemaps.com/api/v2/search" \
  -H "Content-Type: application/json" \
  -H "Authorization: bearer YOUR_ACCESS_TOKEN_HERE" \
  -d '{
    "startDate": "2025-12-17T00:00:00",
    "endDate": "2025-12-18T00:00:00",
    "pageNumber": 1
  }'

curl -X POST "https://routereporterservice.trimblemaps.com/api/v2/search" \
  -H "Content-Type: application/json" \
  -H "Authorization: bearer YOUR_ACCESS_TOKEN_HERE" \
  -d '{
    "startDate": "2025-12-17T00:00:00",
    "endDate": "2025-12-18T00:00:00",
    "pageNumber": 0,
    "vehicleIds": ["vehicle1", "vehicle2"],
    "driverIds": ["driver1", "driver2"],
    "vehicleGroupName": "MyVehicleGroup",
    "driverGroupName": "MyDriverGroup",
    "hasEvents": true
  }'

// =============================================================================
// CONFIGURATION
// =============================================================================

// Replace with your actual API key
const API_KEY = "YOUR_API_KEY_HERE";

// API Endpoints
const AUTH_URL = "https://api.trimblemaps.com/identity/v2/token";
const SEARCH_URL = "https://routereporterservice.trimblemaps.com/api/v2/search";

// =============================================================================
// UTILITY FUNCTIONS
// =============================================================================

/**
 * Sleep for a specified number of milliseconds
 * @param {number} ms - Milliseconds to sleep
 * @returns {Promise} Promise that resolves after the delay
 */
function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

/**
 * Format a date as ISO string without timezone (YYYY-MM-DDTHH:mm:ss)
 * @param {Date} date - Date to format
 * @returns {string} Formatted date string
 */
function formatDate(date) {
    return date.toISOString().slice(0, 19);
}

// =============================================================================
// AUTHENTICATION
// =============================================================================

/**
 * Authenticate with the Trimble Maps API and retrieve an access token.
 * @param {string} apiKey - Your RouteReporter API key
 * @returns {Promise<string>} The access token
 * @throws {Error} If authentication fails
 */
async function getAccessToken(apiKey) {
    const response = await fetch(AUTH_URL, {
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify({
            apiKey: apiKey
        })
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Authentication failed: ${response.status} - ${errorText}`);
    }

    const tokenData = await response.json();
    return tokenData.access_token;
}

// =============================================================================
// TRIP SEARCH WITH PAGINATION
// =============================================================================

/**
 * Search for all trips within the specified date range.
 * Handles pagination automatically and respects rate limits.
 * @param {string} accessToken - Bearer token from authentication
 * @param {Date} startDate - Start of date range
 * @param {Date} endDate - End of date range
 * @returns {Promise<Array>} List of all trip objects
 */
async function searchTrips(accessToken, startDate, endDate) {
    const headers = {
        "Content-Type": "application/json",
        "Authorization": `bearer ${accessToken}`
    };

    // Variable to store all trips from all pages
    let allTrips = [];

    let pageNumber = 0;
    let totalPages = null;

    while (true) {
        const payload = {
            startDate: formatDate(startDate),
            endDate: formatDate(endDate),
            pageNumber: pageNumber
        };

        console.log(`Fetching page ${pageNumber}${totalPages ? '/' + totalPages : ''}...`);

        const response = await fetch(SEARCH_URL, {
            method: "POST",
            headers: headers,
            body: JSON.stringify(payload)
        });

        // Handle rate limiting (429 Too Many Requests)
        if (response.status === 429) {
            // Get retry-after header, default to 60 seconds
            const retryAfter = parseInt(response.headers.get("retry-after") || "60", 10);
            console.log(`Rate limited. Waiting ${retryAfter} seconds before retrying...`);
            await sleep(retryAfter * 1000);
            continue; // Retry the same page
        }

        if (!response.ok) {
            const errorText = await response.text();
            throw new Error(`Search failed: ${response.status} - ${errorText}`);
        }

        const data = await response.json();

        // Extract results and add to our collection
        const results = data.results || [];
        allTrips = allTrips.concat(results);

        // Get pagination info from first response
        if (totalPages === null) {
            totalPages = data.totalPages || 1;
            const totalTrips = data.totalTrips || 0;
            console.log(`Total trips to fetch: ${totalTrips} across ${totalPages} page(s)`);
        }

        console.log(`  Retrieved ${results.length} trips from page ${pageNumber}`);

        // Check if we've fetched all pages (pages are zero-based: 0 .. totalPages - 1)
        if (pageNumber >= totalPages - 1) {
            break;
        }

        // Move to next page
        pageNumber++;

        // Rate limiting: pause 1 second between requests
        await sleep(1000);
    }

    return allTrips;
}

// =============================================================================
// MAIN EXECUTION
// =============================================================================

/**
 * Main function to export a day's worth of trips from RouteReporter.
 * @returns {Promise<Array>} All trips from the last 24 hours
 */
async function exportTrips() {
    console.log("=".repeat(60));
    console.log("RouteReporter Trip Export");
    console.log("=".repeat(60));

    // Step 1: Authenticate
    console.log("\n[1/3] Authenticating...");
    let accessToken;
    try {
        accessToken = await getAccessToken(API_KEY);
        console.log("  Authentication successful!");
    } catch (error) {
        console.error(`  ERROR: ${error.message}`);
        return [];
    }

    // Step 2: Calculate date range (last 24 hours)
    console.log("\n[2/3] Setting up date range...");
    const endDate = new Date();
    const startDate = new Date(endDate.getTime() - 24 * 60 * 60 * 1000); // 24 hours ago
    console.log(`  From: ${startDate.toLocaleString()}`);
    console.log(`  To:   ${endDate.toLocaleString()}`);

    // Step 3: Fetch all trips
    console.log("\n[3/3] Fetching trips...");
    let allTrips;
    try {
        allTrips = await searchTrips(accessToken, startDate, endDate);
    } catch (error) {
        console.error(`  ERROR: ${error.message}`);
        return [];
    }

    // ==========================================================================
    // ALL COMPLETE!
    // The 'allTrips' variable now contains all trip data from the last 24 hours.
    // Each trip is an object with fields like:
    //   - tripID
    //   - externalTripID
    //   - vehicleID, vehicleName
    //   - driverID, driverName
    //   - status (InProgress, Completed, Canceled, Modified, Planned)
    //   - plannedDistance, actualDistance
    //   - plannedDuration, actualDuration
    //   - origin, destination
    //   - startTime, endTime
    //   - and more...
    // ==========================================================================

    console.log("\n" + "=".repeat(60));
    console.log("EXPORT COMPLETE!");
    console.log("=".repeat(60));
    console.log(`Total trips retrieved: ${allTrips.length}`);
    console.log("\nThe 'allTrips' variable contains all trip data.");
    console.log("You can now process, save, or analyze this data as needed.");

    // Example: Print first trip summary (if any trips exist)
    if (allTrips.length > 0) {
        const firstTrip = allTrips[0];
        console.log("\nSample trip data (first trip):");
        console.log(`  Trip ID: ${firstTrip.tripID}`);
        console.log(`  Vehicle: ${firstTrip.vehicleName} (${firstTrip.vehicleID})`);
        console.log(`  Status: ${firstTrip.status}`);
        console.log(`  Distance: ${firstTrip.actualDistance} miles`);
    }

    return allTrips;
}

// =============================================================================
// RUN THE EXPORT
// =============================================================================

// Execute the export and store results
let allTrips;
exportTrips().then(trips => {
    allTrips = trips;
    // You can now work with allTrips here
    // Example: console.log(JSON.stringify(allTrips, null, 2));
});

const payload = {
    startDate: formatDate(startDate),
    endDate: formatDate(endDate),
    pageNumber: pageNumber,
    // Optional filters:
    vehicleIds: ["vehicle1", "vehicle2"],      // Filter by specific vehicles
    driverIds: ["driver1", "driver2"],         // Filter by specific drivers
    vehicleGroupName: "MyVehicleGroup",        // Filter by vehicle group
    driverGroupName: "MyDriverGroup",          // Filter by driver group
    hasEvents: true                            // Only trips with events
};

import requests
import time
from datetime import datetime, timedelta

# =============================================================================
# CONFIGURATION
# =============================================================================

# Replace with your actual API key
API_KEY = "YOUR_API_KEY_HERE"

# API Endpoints
AUTH_URL = "https://api.trimblemaps.com/identity/v2/token"
SEARCH_URL = "https://routereporterservice.trimblemaps.com/api/v2/search"

# =============================================================================
# AUTHENTICATION
# =============================================================================

def get_access_token(api_key):
    """
    Authenticate with the Trimble Maps API and retrieve an access token.

    Args:
        api_key: Your RouteReporter API key

    Returns:
        The access token string

    Raises:
        Exception: If authentication fails
    """
    headers = {
        "Content-Type": "application/json"
    }

    payload = {
        "apiKey": api_key
    }

    response = requests.post(AUTH_URL, json=payload, headers=headers)

    if response.status_code != 200:
        raise Exception(f"Authentication failed: {response.status_code} - {response.text}")

    token_data = response.json()
    return token_data["access_token"]

# =============================================================================
# TRIP SEARCH WITH PAGINATION
# =============================================================================

def search_trips(access_token, start_date, end_date):
    """
    Search for all trips within the specified date range.
    Handles pagination automatically and respects rate limits.

    Args:
        access_token: Bearer token from authentication
        start_date: Start of date range (datetime object)
        end_date: End of date range (datetime object)

    Returns:
        List of all trip objects
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"bearer {access_token}"
    }

    # Variable to store all trips from all pages
    all_trips = []

    page_number = 0
    total_pages = None

    while True:
        payload = {
            "startDate": start_date.strftime("%Y-%m-%dT%H:%M:%S"),
            "endDate": end_date.strftime("%Y-%m-%dT%H:%M:%S"),
            "pageNumber": page_number
        }

        print(f"Fetching page {page_number}{'/' + str(total_pages) if total_pages else ''}...")

        response = requests.post(SEARCH_URL, json=payload, headers=headers)

        # Handle rate limiting (429 Too Many Requests)
        if response.status_code == 429:
            # Get retry-after header, default to 60 seconds
            retry_after = int(response.headers.get("retry-after", 60))
            print(f"Rate limited. Waiting {retry_after} seconds before retrying...")
            time.sleep(retry_after)
            continue  # Retry the same page

        if response.status_code != 200:
            raise Exception(f"Search failed: {response.status_code} - {response.text}")

        data = response.json()

        # Extract results and add to our collection
        results = data.get("results", [])
        all_trips.extend(results)

        # Get pagination info from first response
        if total_pages is None:
            total_pages = data.get("totalPages", 1)
            total_trips = data.get("totalTrips", 0)
            print(f"Total trips to fetch: {total_trips} across {total_pages} page(s)")

        print(f"  Retrieved {len(results)} trips from page {page_number}")

        # Check if we've fetched all pages
        if page_number >= total_pages:
            break

        # Move to next page
        page_number += 1

        # Rate limiting: pause 1 second between requests
        time.sleep(1)

    return all_trips

# =============================================================================
# MAIN EXECUTION
# =============================================================================

def main():
    """
    Main function to export a day's worth of trips from RouteReporter.
    """
    print("=" * 60)
    print("RouteReporter Trip Export")
    print("=" * 60)

    # Step 1: Authenticate
    print("\n[1/3] Authenticating...")
    try:
        access_token = get_access_token(API_KEY)
        print("  Authentication successful!")
    except Exception as e:
        print(f"  ERROR: {e}")
        return

    # Step 2: Calculate date range (last 24 hours)
    print("\n[2/3] Setting up date range...")
    end_date = datetime.now()
    start_date = end_date - timedelta(days=1)
    print(f"  From: {start_date.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"  To:   {end_date.strftime('%Y-%m-%d %H:%M:%S')}")

    # Step 3: Fetch all trips
    print("\n[3/3] Fetching trips...")
    try:
        all_trips = search_trips(access_token, start_date, end_date)
    except Exception as e:
        print(f"  ERROR: {e}")
        return

    # ==========================================================================
    # ALL COMPLETE!
    # The 'all_trips' variable now contains all trip data from the last 24 hours.
    # Each trip is a dictionary with fields like:
    #   - tripID
    #   - externalTripID
    #   - vehicleID, vehicleName
    #   - driverID, driverName
    #   - status (InProgress, Completed, Canceled, Modified, Planned)
    #   - plannedDistance, actualDistance
    #   - plannedDuration, actualDuration
    #   - origin, destination
    #   - startTime, endTime
    #   - and more...
    # ==========================================================================

    print("\n" + "=" * 60)
    print("EXPORT COMPLETE!")
    print("=" * 60)
    print(f"Total trips retrieved: {len(all_trips)}")
    print("\nThe 'all_trips' variable contains all trip data.")
    print("You can now process, save, or analyze this data as needed.")

    # Example: Print first trip summary (if any trips exist)
    if all_trips:
        first_trip = all_trips[0]
        print("\nSample trip data (first trip):")
        print(f"  Trip ID: {first_trip.get('tripID')}")
        print(f"  Vehicle: {first_trip.get('vehicleName')} ({first_trip.get('vehicleID')})")
        print(f"  Status: {first_trip.get('status')}")
        print(f"  Distance: {first_trip.get('actualDistance')} miles")

    return all_trips


if __name__ == "__main__":
    # Run the export and store results
    all_trips = main()

payload = {
    "startDate": start_date.strftime("%Y-%m-%dT%H:%M:%S"),
    "endDate": end_date.strftime("%Y-%m-%dT%H:%M:%S"),
    "pageNumber": page_number,
    # Optional filters:
    "vehicleIds": ["vehicle1", "vehicle2"],      # Filter by specific vehicles
    "driverIds": ["driver1", "driver2"],         # Filter by specific drivers
    "vehicleGroupName": "MyVehicleGroup",        # Filter by vehicle group
    "driverGroupName": "MyDriverGroup",          # Filter by driver group
    "hasEvents": True                            # Only trips with events
}