Ought Solution
Biometric Systems & ERP Integration

How to Sync Biometric Attendance Machines Directly to Payroll & ERP Using Cloud Push API

Stop wasting hours exporting attendance logs via USB drives and messy CSV sheets. Learn how Cloud Push API (ADMS/WDMS) technology streams real-time biometric punch data directly from remote devices into your custom ERP…

OAOught Solution AdminAuthor7 min read
Architecture diagram showing biometric attendance cloud push API payroll integration syncing real-time punch logs from an attendance device to a cloud ERP server.

At the end of every month, thousands of HR managers and IT administrators go through the same tedious ritual: walking up to biometric devices with a USB pen drive, pulling raw .dat or .csv files, fixing broken date formats in Excel, and manually uploading sheets into payroll software.

When you manage a single office, this is a minor annoyance. When you manage a distributed workforce across multiple branches, warehouses, or a large Manufacturing Unit / Plant, manual attendance reconciliation becomes an operational bottleneck that leads to payroll delays, overtime calculation errors, and compliance risks.

The solution isn’t buying more expensive hardware—it’s changing how your devices communicate with your software. By implementing a biometric attendance cloud push API payroll integration, your attendance terminals automatically stream punch data to your central server the exact millisecond an employee scans their face, fingerprint, or RFID card.

Here is the complete architectural breakdown of how Cloud Push technology works, why it outperforms legacy polling methods, and how to integrate it directly with your ERP or payroll engine.

Pull SDK vs. Cloud Push API: Why Legacy Syncing Fails

Historically, biometric attendance systems relied on a Pull SDK architecture. In a Pull setup, a local desktop computer running attendance software had to sit on the same Local Area Network (LAN) as the biometric machines. The computer would periodically "ping" each device, open a TCP/IP port, and download the punch logs.

FeatureLegacy Pull SDK (LAN/Static IP)Modern Cloud Push API (ADMS / HTTP)
Data DirectionServer requests data from the device on a scheduleDevice pushes data to the server instantly upon punch
Network RequirementRequires Static IP, VPN, or complex Port ForwardingWorks on any standard internet connection (Wi-Fi, LAN, 4G SIM)
Multi-Location ScalabilityPoor; breaks easily across remote sitesHigh; 1 to 1,000+ remote devices point to one central URL
Sync LatencyBatch sync (every few hours or end-of-day)Real-time (under 2 seconds per transaction)
Firewall RiskHigh (requires inbound ports open at branch offices)Low (uses standard outbound HTTP/HTTPS requests)

With a Cloud Push API (often powered by ADMS—Automatic Data Master Server—or native HTTP/HTTPS Webhooks built into modern firmware), the biometric machine acts as a web client. You simply configure the machine with your cloud server’s domain name or IP address and port. Whenever a punch occurs, the device initiates an outbound HTTP POST request directly to your API endpoint.

How the Cloud Push Architecture Works (Step-by-Step)

To achieve a seamless biometric attendance cloud push API payroll integration, four layers work together in real time:

1. The Hardware Layer (Biometric Terminal)

An employee marks attendance using facial recognition, fingerprint, palm vein, or RFID. The device validates the template locally in milliseconds, stores a backup log in its internal flash memory, and formats an HTTP packet containing the Device Serial Number (SN), Employee ID (PIN), Timestamp, and Verification Mode.

2. The Listener Endpoint (Middleware / API Gateway)

Your cloud server hosts a lightweight listener endpoint (commonly built in PHP, Node.js, or Python). The endpoint performs three critical tasks:

  • Handshake & Heartbeat: Responds to the device’s /iclock/cdata or webhook ping to confirm the server is alive.

  • Authentication: Verifies that the incoming Device Serial Number is registered and authorized in your database.

  • Acknowledgement (OK Response): Returns an immediate HTTP 200 OK response to the biometric machine. If the internet drops and the machine doesn't receive an OK, it holds the punch in its local queue and automatically retries once connectivity is restored—guaranteeing zero data loss.

3. The Shift & Rule Engine (Database Processing)

Raw biometric logs are just timestamps—they are not yet payroll-ready. Once the raw punch lands in your MySQL or PostgreSQL database, your business logic layer processes the raw timestamps against company policies:

  • First-In / Last-Out (FILO) or Every-Punch pairing: Filters out duplicate punches made within 2 minutes (debounce logic).

  • Night Shift Cross-Day Handling: Correctly pairs a 20:00 check-in on Monday with an 05:00 check-out on Tuesday as a single shift rather than two incomplete days.

  • Grace Period & Late Marks: Automatically flags late arrivals (e.g., 3 late marks = 0.5 day LOP) and calculates overtime hours based on shift rosters.

4. The ERP & Payroll Sync

Once the attendance engine computes the daily status (Present, Half-Day, Absent, Overtime Hours, Week-Off), it pushes the clean, structured data directly into your ERP or payroll tables—or triggers a webhook to third-party HRMS platforms—ready for one-click salary disbursement.

Sample JSON Payload & API Processing Workflow

When you use our custom middleware or a webhook-enabled biometric system, the data arriving at your ERP endpoint looks clean and structured like this:

{
  "event_type": "attendance_log",
  "device_sn": "OSBIOM202609881",
  "location_id": "PLANT_UNIT_01",
  "employee_code": "EMP1042",
  "punch_time": "2026-11-15 08:58:14",
  "verify_mode": "FACE",
  "in_out_status": "CHECK_IN",
  "work_code": "0"
}

Sample PHP Endpoint Logic for Capturing Real-Time Punches

If your ERP or custom portal runs on a Linux/PHP/MySQL stack, here is how a clean API listener captures and deduplicates incoming attendance pushes:

<?php
header("Content-Type: application/json");

// 1. Capture raw payload from Biometric Cloud Push / Middleware
$rawPayload = file_get_contents("php://input");
$data = json_decode($rawPayload, true);

if (!$data || empty($data['device_sn']) || empty($data['employee_code'])) {
    http_response_code(400);
    echo json_encode(["status" => "error", "message" => "Invalid payload"]);
    exit;
}

// 2. Database Connection (PDO)
$pdo = new PDO("mysql:host=localhost;dbname=erp_payroll;charset=utf8mb4", "db_user", "db_password", [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]);

// 3. Insert with Deduplication (Prevents duplicate retries from network flickers)
$stmt = $pdo->prepare("
    INSERT IGNORE INTO biometric_raw_logs 
    (device_sn, employee_code, punch_time, verify_mode, in_out_status, created_at)
    VALUES (:sn, :emp, :ptime, :vmode, :status, NOW())
");

$stmt->execute([
    ':sn'     => $data['device_sn'],
    ':emp'    => $data['employee_code'],
    ':ptime'  => $data['punch_time'],
    ':vmode'  => $data['verify_mode'] ?? 'FP_FACE',
    ':status' => $data['in_out_status'] ?? 'AUTO'
]);

// 4. Return HTTP 200 OK so the biometric device clears its queue
http_response_code(200);
echo "OK";
?>

5 Critical Challenges to Solve Before Going Live

Integrating hardware with payroll software requires more than just capturing timestamps. Make sure your integration architecture accounts for these five real-world edge cases:

  1. Offline Buffer & Auto-Resync: Internet connections at remote sites and industrial plants drop frequently. Ensure your biometric hardware has ADMS push-queue firmware that stores 100,000+ logs locally and automatically flushes them in chronological order once the network reconnects.

  2. Centralized User Enrollment: You shouldn't have to enroll an employee's fingerprint or face at every gate. With a bidirectional Cloud Push API, enrolling a worker on one master device uploads their biometric template to the cloud server, which then automatically distributes that template to all authorized branch machines.

  3. Canteen & Access Control Separation: Many enterprises use the same hardware ecosystem for door access control, canteen meal tokens, and shift attendance. Your API middleware must filter logs by device_sn or function_key so a lunch punch in the canteen isn't accidentally logged as an early shift check-out in payroll.

  4. Timezone & NTP Synchronization: If a biometric machine's internal CMOS battery weakens or drifts by 15 minutes, employees get unfairly marked late. Configure your Cloud Push server to enforce automatic NTP (Network Time Protocol) sync during every device heartbeat.

  5. Overtime & Compoff Guardrails: Never feed raw overtime hours directly into net pay without an approval flag. Configure your ERP integration so calculated overtime sits in a "Pending Supervisor Approval" queue before locking into the monthly payroll run.

Ready to Automate Your Attendance-to-Payroll Pipeline?

Whether you are deploying brand-new Face & Fingerprint terminals across a Manufacturing Unit / Plant, or you want to connect your existing eSSL, ZKTeco, Realtime, Mantra, or Biomax devices to a custom ERP, Ought Solution builds end-to-end hardware and software bridges tailored to your workflow.

We provide:

  • Cloud Push Biometric Hardware: Pre-configured 4G, Wi-Fi, and LAN biometric attendance and access control terminals with native ADMS/Cloud Push support.

  • Custom API Middleware & Webhooks: Secure cloud listeners that convert raw hardware protocols into clean REST APIs for your ERP, HRMS, or custom PHP/MySQL and enterprise web applications.

  • Turnkey Canteen & Shift Management: Unified ecosystems covering rotational shifts, contractor workforce tracking, gate access control, and automated payroll calculation.

Contact Ought Solution Today to schedule a free technical consultation and live API demo for your organization.

Enjoyed this? Share it
Ought Solution Admin
Written byOught Solution Admin

Ought Solution Admin is the technical editorial and solutions architecture desk at Ought Solution, a global B2B IT consulting, custom ERP software, and biometric hardware integration firm. Drawing from hands-on deployments across Manufacturing Units / Plants, healthcare diagnostics, educational campuses, and corporate…

FAQ

Frequently asked questions

What is a biometric attendance Cloud Push API (ADMS/WDMS), and how does it work?

A biometric attendance Cloud Push API—commonly referred to as ADMS (Automatic Data Master Server) or WDMS—is a real-time data transmission protocol built into modern time-attendance hardware. Instead of requiring a local computer to repeatedly request data from the machine, the biometric device acts as a web client. The moment an employee scans their fingerprint, face, or RFID card, the machine automatically sends an outbound HTTP/HTTPS POST request containing the punch details directly to your cloud ERP or payroll server URL.

Do I need a static IP address or port forwarding at every branch office for Cloud Push integration?

No. One of the biggest advantages of biometric attendance cloud push API payroll integration over legacy Pull SDK systems is that you only need a single static IP or domain name at your central cloud server. Your remote biometric machines across multiple offices, warehouses, or a Manufacturing Unit / Plant only require a standard outbound internet connection (broadband LAN, Wi-Fi, or a 4G SIM card) to push attendance logs in real time.

What happens to attendance data if the internet disconnects at our office or plant?

Zero attendance data is lost during an internet outage. Cloud Push biometric terminals feature non-volatile internal flash memory capable of storing 100,000 to 500,000+ offline punch logs. If the network drops or your cloud server fails to return an HTTP 200 OK acknowledgement, the device queues the punches locally with their original timestamps. Once internet connectivity is restored, the hardware automatically flushes the backlog to the payroll server in chronological order.

Which biometric machine brands support Cloud Push API to custom ERP and payroll software?

Most enterprise-grade biometric attendance and access control hardware manufacturers support Cloud Push or ADMS protocols—either natively in the firmware or via licensed push modules. Compatible systems include eSSL, ZKTeco, Realtime, Biomax, Mantra, Matrix COSEC, and Hikvision. Ought Solution provides both pre-configured push-enabled hardware and custom API middleware to bridge your existing devices with any software stack.

How fast do biometric punches sync to the payroll database using Cloud Push API?

Under normal network conditions, real-time attendance synchronization takes less than 1 to 2 seconds. As soon as a worker verifies their identity on the terminal, the punch payload hits the listener endpoint, gets validated by the shift engine, and updates the live attendance dashboard and ERP database instantly.

How does the API handle complex rotational shifts, night shifts, and overtime calculations?

Raw biometric hardware only records a timestamp, User ID, and Device Serial Number. When integrating via Cloud Push API, a middleware shift engine processes these raw logs before sending them to payroll:

  • Night Shift Cross-Day Logic: Pairs an evening check-in (e.g., 8:00 PM Monday) with a morning check-out (e.g., 5:00 AM Tuesday) under the Monday shift roster.
  • Duplicate Punch Filtering (Debounce): Ignores accidental double punches made within a configurable window (e.g., 2 to 5 minutes).
  • Automated Overtime & LOP: Compares total worked hours against scheduled shift timings, grace periods, and break deductions to calculate exact payable hours and Loss of Pay (LOP) days.

Can we separate gate access control, canteen management, and shift attendance logs using the same API?

Yes. Every Cloud Push payload includes a unique Device Serial Number (SN) and verification code. Your API endpoint can route incoming punches into separate database tables based on the machine's assigned role—ensuring that a door-unlock scan or a canteen meal token print is never miscounted as an early shift check-out in your payroll calculation.

Can a Cloud Push API sync new employee enrollments and biometric templates across multiple locations?

Yes. Cloud Push (ADMS) supports bidirectional communication. When HR enrolls a new employee’s face or fingerprint template on a single master biometric machine at head office, the template is pushed to the central cloud server. The server can then automatically distribute that employee's biometric credentials and access permissions to authorized terminals across other branches or sites without manual re-enrollment.

What programming languages and databases can receive biometric Cloud Push API data?

Because Cloud Push relies on standard HTTP/HTTPS web requests and JSON or plain-text payloads, it is 100% platform-agnostic. You can build or connect your listener endpoint using PHP (Laravel/CodeIgniter/Core PHP), Node.js, Python, .NET, or Java, and store logs directly in MySQL, PostgreSQL, MS SQL Server, or MongoDB, as well as push webhooks into third-party HRMS and ERP platforms.

How is biometric data secured during transmission from the machine to the cloud payroll server?

Enterprise biometric API integrations secure data in transit and at rest using multiple layers:

  • HTTPS / TLS Encryption: Encrypts payload packets between the terminal and the cloud server.

  • Device Serial Number Whitelisting & API Tokens: Rejects unauthorized payloads from unknown machines or spoofed IP addresses.

  • Mathematical Template Hashing: Biometric devices do not transmit raw photographs of fingerprints; instead, they convert biometric features into encrypted mathematical strings (templates) that cannot be reverse-engineered into an image.

Keep reading

More articles

Tell us what you need - we will suggest the right solution

Free consultation. A clear proposal within 24 hours.

Contact us