Euro Games Technology—now primarily recognized in the digital space under the Amusnet banner—holds a legendary status in the iGaming world. Known for timeless land-based classics, high-volatility math models, and multi-tier mystery progressive jackpots, EGT titles (such as 40 Super Hot, Burning Hot, and Shining Crown) are mandatory fixtures for operators aiming to drive retention across European, Latin American, and emerging markets.
Integrating EGT gaming content through an API connects an operator’s platform directly to these proven titles. Below is an end-to-end breakdown of how EGT API integration functions, the architecture powering it, and the operational steps required to go live.
EGT games bring a distinct player demographic that differs significantly from modern cascading-reel or high-concept video slots:
High Player Loyalty & Instant Recognition: The retro fruit mechanics, authentic sound designs, and straightforward reel mechanics attract high-turnover legacy and VIP players.
Jackpot Cards Feature: EGT’s signature four-level mystery jackpot (Clubs, Diamonds, Hearts, and Spades) triggers randomly, providing an adrenaline boost and gamification layer that significantly bolsters player session lengths.
Cross-Platform HTML5 Engine: Fully optimized responsive frameworks ensure smooth gameplay across mobile browsers, desktop web, and native mobile wrappers without framerate degradation.
When integrating EGT games via a unified API or aggregator, platforms typically choose between two architectural patterns:
| Parameter | Seamless Wallet (Single Wallet) | Transfer Wallet (Credit / Debit Relay) |
| User Experience | Instant play; balance updates live directly from the player's core casino account. | Players manually transfer funds into a separate "EGT Game Wallet" before launching. |
| Latency Tolerance | Requires low API response times (< 200 ms) for bet/win callbacks. | Less sensitive to real-time latency spikes since balance is local during play. |
| Implementation Complexity | Higher; requires atomic transaction locking and strict rollback handling. | Lower; isolated accounting reduces risk of race conditions on the main wallet. |
| Industry Adoption | Standard (95%+ of modern platforms) | Legacy; primarily used in restricted regulatory jurisdictions. |
A standard EGT API implementation relies on a bidirectional client-server and server-to-server (S2S) communication loop:
Authentication & Game Launch (getGameUrl):
The player clicks a game tile in the casino lobby.
The operator’s backend makes an S2S call to the EGT/Aggregator API, passing player_id, session_token, currency, and language.
The API returns a signed, temporary launch URL embedded into an iframe or web view.
Balance Query (getBalance):
When the game loads, EGT’s game server pings the operator's callback URL to verify that the player has funds to place a wager.
Round Settlement (debit and credit callbacks):
Debit (Bet): The player presses spin; EGT immediately fires a webhook debiting the bet amount from the operator's wallet.
Credit (Win): When the spin settles (including any Gamble feature or Jackpot Cards payout), EGT notifies the operator to credit the winnings.
Rollback: If a spin fails or a network issue disconnects the round mid-flight, an automatic rollback callback voids the transaction and refunds the wager.
Building a resilient casino API integration requires defensive coding around the wallet callbacks:
Strict Idempotency: Webhooks can be resent during network hiccups. Every transaction comes with a unique round_id and transaction_id. Your wallet service must verify that a transaction hasn't already been processed before mutating user balances.
Cryptographic Signatures (HMAC/Salt): Incoming callbacks from the game server must be verified via HMAC-SHA256 signatures or secret salt hashes to protect against spoofing. Allowlisting vendor callback IP addresses adds an essential layer of perimeter security.
Jackpot Contribution Handling: EGT's Jackpot Cards system collects a small contribution percentage from qualifying spins. Your accounting ledger must correctly classify gross wagers versus net RTP payouts for accurate GGR (Gross Gaming Revenue) reconciliations.
Currency and Denomination Rounding: Ensure strict decimal precision (typically DECIMAL(18, 4)) in database schemas to prevent fractional rounding drift across multi-currency wagering engines.
Launching EGT titles can be approached via two business routes:
Direct Integration: Working directly with the studio (Amusnet). This yields optimal commercial margins (lower revenue share / GGR fees). However, it comes with stricter minimum revenue guarantees, direct technical compliance audits, and lengthy onboarding queues.
Unified Aggregator API: Integrating via tier-1 iGaming aggregators (e.g., SoftSwiss, EveryMatrix, Slotegrator, LuckyStreak). Aggregators bundle EGT alongside hundreds of other studios under a single API contract. This cuts development time from months to days, drastically simplifies KYC/compliance pipelines, and offers single-invoice monthly settlements.
Adding EGT's classic slot library through a standardized, low-latency API remains one of the fastest routes for an operator to drive engagement and cater to high-value slot traditionalists worldwide.
Here an example webhook handler showing seamless balance, debit, and credit logic?
Below is a production-ready Node.js (Express) implementation of a Seamless Wallet webhook handler for casino game callbacks.
It handles balance, debit (wager), credit (win), and rollback actions while enforcing three critical iGaming requirements: HMAC-SHA256 signature verification, strict idempotency, and atomic database balance updates to prevent race conditions.
import express from 'express';
import crypto from 'crypto';
import pg from 'pg';
const app = express();
// Capture raw body buffer for accurate HMAC calculation before JSON parsing
app.use(express.json({
verify: (req, res, buf) => {
req.rawBody = buf;
}
}));
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
const PROVIDER_SECRET = process.env.PROVIDER_WEBHOOK_SECRET || 'your_shared_secret_key';
// Standard error codes expected by casino aggregators
const ERROR_CODES = {
INVALID_SIGNATURE: 'ERR_INVALID_SIGNATURE',
PLAYER_NOT_FOUND: 'ERR_PLAYER_NOT_FOUND',
INSUFFICIENT_FUNDS: 'ERR_INSUFFICIENT_FUNDS',
TX_ALREADY_PROCESSED: 'ERR_TX_EXISTS',
INTERNAL_ERROR: 'ERR_INTERNAL'
};
// 1. Security Middleware: Verify HMAC-SHA256 signature
function verifyProviderSignature(req, res, next) {
const signature = req.headers['x-provider-signature'];
if (!signature) {
return res.status(401).json({ status: 'ERROR', code: ERROR_CODES.INVALID_SIGNATURE });
}
const computedHash = crypto
.createHmac('sha256', PROVIDER_SECRET)
.update(req.rawBody)
.digest('hex');
const trustedBuf = Buffer.from(computedHash, 'utf-8');
const suppliedBuf = Buffer.from(signature, 'utf-8');
// Prevent timing attacks
if (trustedBuf.length !== suppliedBuf.length || !crypto.timingSafeEqual(trustedBuf, suppliedBuf)) {
return res.status(403).json({ status: 'ERROR', code: ERROR_CODES.INVALID_SIGNATURE });
}
next();
}
app.use('/api/v1/casino/callback', verifyProviderSignature);
// 2. Central Webhook Router
app.post('/api/v1/casino/callback', async (req, res) => {
const { action, player_id, transaction_id, round_id, amount, currency } = req.body;
const client = await pool.connect();
try {
switch (action) {
case 'balance': {
const { rows } = await client.query(
'SELECT balance, currency FROM accounts WHERE player_id = $1',
[player_id]
);
if (!rows.length) {
return res.status(404).json({ status: 'ERROR', code: ERROR_CODES.PLAYER_NOT_FOUND });
}
return res.json({
status: 'OK',
player_id,
balance: parseFloat(rows[0].balance),
currency: rows[0].currency
});
}
case 'debit': {
await client.query('BEGIN');
// Check idempotency: If this transaction_id already exists, return current balance
const existingTx = await client.query(
'SELECT id FROM transactions WHERE provider_tx_id = $1',
[transaction_id]
);
if (existingTx.rows.length > 0) {
const { rows } = await client.query(
'SELECT balance FROM accounts WHERE player_id = $1',
[player_id]
);
await client.query('ROLLBACK');
return res.json({ status: 'OK', balance: parseFloat(rows[0].balance) });
}
// Lock user record to prevent race conditions during concurrent bets
const accountRes = await client.query(
'SELECT balance FROM accounts WHERE player_id = $1 FOR UPDATE',
[player_id]
);
if (!accountRes.rows.length) {
await client.query('ROLLBACK');
return res.status(404).json({ status: 'ERROR', code: ERROR_CODES.PLAYER_NOT_FOUND });
}
const currentBalance = parseFloat(accountRes.rows[0].balance);
const betAmount = parseFloat(amount);
if (currentBalance < betAmount) {
await client.query('ROLLBACK');
return res.status(400).json({ status: 'ERROR', code: ERROR_CODES.INSUFFICIENT_FUNDS });
}
// Apply debit
const updateRes = await client.query(
'UPDATE accounts SET balance = balance - $1 WHERE player_id = $2 RETURNING balance',
[betAmount, player_id]
);
// Record ledger entry
await client.query(
`INSERT INTO transactions (player_id, provider_tx_id, round_id, type, amount, status)
VALUES ($1, $2, $3, 'DEBIT', $4, 'COMPLETED')`,
[player_id, transaction_id, round_id, betAmount]
);
await client.query('COMMIT');
return res.json({
status: 'OK',
transaction_id,
balance: parseFloat(updateRes.rows[0].balance)
});
}
case 'credit': {
await client.query('BEGIN');
// Idempotency check
const existingTx = await client.query(
'SELECT id FROM transactions WHERE provider_tx_id = $1',
[transaction_id]
);
if (existingTx.rows.length > 0) {
const { rows } = await client.query(
'SELECT balance FROM accounts WHERE player_id = $1',
[player_id]
);
await client.query('ROLLBACK');
return res.json({ status: 'OK', balance: parseFloat(rows[0].balance) });
}
const winAmount = parseFloat(amount);
// Apply credit
const updateRes = await client.query(
'UPDATE accounts SET balance = balance + $1 WHERE player_id = $2 RETURNING balance',
[winAmount, player_id]
);
if (!updateRes.rows.length) {
await client.query('ROLLBACK');
return res.status(404).json({ status: 'ERROR', code: ERROR_CODES.PLAYER_NOT_FOUND });
}
// Record ledger entry
await client.query(
`INSERT INTO transactions (player_id, provider_tx_id, round_id, type, amount, status)
VALUES ($1, $2, $3, 'CREDIT', $4, 'COMPLETED')`,
[player_id, transaction_id, round_id, winAmount]
);
await client.query('COMMIT');
return res.json({
status: 'OK',
transaction_id,
balance: parseFloat(updateRes.rows[0].balance)
});
}
case 'rollback': {
const { original_transaction_id } = req.body;
await client.query('BEGIN');
// Check if the original transaction was already voided/rolled back
const existingRollback = await client.query(
'SELECT id FROM transactions WHERE provider_tx_id = $1',
[transaction_id]
);
if (existingRollback.rows.length > 0) {
const { rows } = await client.query(
'SELECT balance FROM accounts WHERE player_id = $1',
[player_id]
);
await client.query('ROLLBACK');
return res.json({ status: 'OK', balance: parseFloat(rows[0].balance) });
}
// Find the target transaction to reverse
const targetTx = await client.query(
'SELECT type, amount FROM transactions WHERE provider_tx_id = $1',
[original_transaction_id]
);
if (!targetTx.rows.length) {
// If debit never hit the system, acknowledge rollback safely without balance modification
await client.query('ROLLBACK');
const { rows } = await client.query(
'SELECT balance FROM accounts WHERE player_id = $1',
[player_id]
);
return res.json({ status: 'OK', balance: parseFloat(rows[0].balance) });
}
const { type, amount: origAmount } = targetTx.rows[0];
let balanceAdjustmentSql = '';
// If reversing a debit, refund the balance; if reversing an unearned credit, deduct it
if (type === 'DEBIT') {
balanceAdjustmentSql = 'UPDATE accounts SET balance = balance + $1 WHERE player_id = $2 RETURNING balance';
} else if (type === 'CREDIT') {
balanceAdjustmentSql = 'UPDATE accounts SET balance = balance - $1 WHERE player_id = $2 RETURNING balance';
}
const updateRes = await client.query(balanceAdjustmentSql, [origAmount, player_id]);
await client.query(
`INSERT INTO transactions (player_id, provider_tx_id, round_id, type, amount, status)
VALUES ($1, $2, $3, 'ROLLBACK', $4, 'COMPLETED')`,
[player_id, transaction_id, round_id, origAmount]
);
await client.query('COMMIT');
return res.json({
status: 'OK',
transaction_id,
balance: parseFloat(updateRes.rows[0].balance)
});
}
default:
return res.status(400).json({ status: 'ERROR', message: `Unknown action: ${action}` });
}
} catch (err) {
await client.query('ROLLBACK');
console.error('Wallet Callback Error:', err);
return res.status(500).json({ status: 'ERROR', code: ERROR_CODES.INTERNAL_ERROR });
} finally {
client.release();
}
});
app.listen(3000, () => console.log('Casino Seamless Wallet running on port 3000'));
To support the concurrency and idempotency checks in the code above, the database tables require unique constraints on provider transaction identifiers:
CREATE TABLE accounts (
player_id VARCHAR(64) PRIMARY KEY,
balance NUMERIC(18, 4) NOT NULL DEFAULT 0.0000,
currency VARCHAR(3) NOT NULL DEFAULT 'EUR',
updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
CREATE TABLE transactions (
id SERIAL PRIMARY KEY,
player_id VARCHAR(64) NOT NULL REFERENCES accounts(player_id),
provider_tx_id VARCHAR(128) NOT NULL UNIQUE,
round_id VARCHAR(128) NOT NULL,
type VARCHAR(16) NOT NULL, -- 'DEBIT', 'CREDIT', 'ROLLBACK'
amount NUMERIC(18, 4) NOT NULL,
status VARCHAR(32) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
CREATE INDEX idx_transactions_round_id ON transactions(round_id);
Hope you understand the method about how to integrate the egt casino games api. here is the official document for more details.
https://cloneslot.com/1673827/egt-casino-game-api-integration.pdf
we offer both API keys and independent full source code for egt casino games. if you want full source code then you can take from this link.
https://cloneslot.com/item/egt-casino-games-slots-source-code
For API keys feel free to reach us on telegram @soultrain1960
When deploying our suite of classic casino slot titles (including high-performing retro titles inspired by EGT / Amusnet mechanics), operators and platform aggregators have varying operational, regulatory, and infrastructural demands.
To accommodate both rapid turnkey launches and fully sovereign proprietary platforms, we offer two delivery formats: Cloud-Hosted API Access and Full Source Code Ownership.
| Feature / Dimension | Hosted API Integration | Source Code Purchase / License |
| Delivery Mechanism | REST / WebSocket API + Game Launch URLs | Full Git Repository (Client HTML5 + Server Engine) |
| Time to Market | 12–23 business days | instant Delivery |
| Infrastructure Overhead | Zero (fully hosted & scaled on our edge servers) | Full operator responsibility (Cloud, DB, CDN, WebSockets) |
| RNG Math Customization | Provider-managed (locked certified RTPs) | 100% customizable (RTP, hit frequency, volatility tables) |
| Ongoing Revenue Share (GGR) | Standard rev-share (e.g., 6%–12% GGR) | 0% GGR (one-time license / flat maintenance fee) |
| Branding & Reskinning | Standard UI with operator logo injection | Unrestricted frontend asset editing & white-labeling |
| Maintenance & Updates | Automatic patches, zero downtime | Self-managed upgrades via release tags |
The Hosted API tier is designed for licensed casino operators, turnkey platform providers, and aggregators who want immediate access to games without running game engines or maintaining math servers.
Game Delivery: The game assets and client frontends are served directly from our global CDN.
Server-to-Server (S2S) Architecture: Spins and RNG math calculations run on our dedicated, high-availability game servers.
Wallet Communication: Balances are tracked via your backend using a low-latency Seamless Wallet webhook relay (balance, debit, credit, rollback).
Merchant Dashboard Access: Real-time analytics, player session monitoring, round histories, and GGR reporting.
API Credentials:
client_id & client_secret
Cryptographic signing salt / HMAC keys
Staging & Production API endpoints
Developer Documentation & SDKs: Ready-to-use Postman collections, Swagger specs, and webhook boilerplate code in Node.js, PHP, and Python.
24/7 Managed Infrastructure: 99.99% SLA uptime, automated DDoS mitigation, and continuous game client updates.
Fast-moving operators prioritizing immediate time-to-market.
Existing online casinos seeking to expand their slot catalog without increasing DevOps overhead.
Platforms preferring a zero-capital-expenditure (CapEx) setup in favor of standard gross gaming revenue (GGR) sharing.
The Source Code license provides unconstrained autonomy for iGaming studios, tier-1 operators, and enterprise technology groups seeking full independence from third-party hosting, uptime dependencies, and recurring rev-share fees.
Frontend Client Source (HTML5 / PixiJS / Canvas):
Unminified TypeScript/JavaScript source code.
Full vector graphic assets, sprite sheets, sound packages, and localization files.
Responsive layout engine supporting mobile, desktop, and tablet portrait/landscape orientations.
Backend Game Logic & RNG Engine:
High-throughput spin settlement engine (Node.js / Go / Java).
Certified RNG math implementation (GLI-19 compliant algorithms).
Configurable payout tables, paylines, and multi-denomination reel strip arrays.
Mystery Progressive Jackpot Engine:
Standalone jackpot daemon managing the 4-tier mystery card system.
Real-time contribution accumulator and broadcast engine over WebSockets.
DevOps & Infrastructure Templates:
Dockerfiles, docker-compose.yml, and Kubernetes Helm charts for auto-scaling under peak concurrency.
Database migration scripts (PostgreSQL / Redis caching layer).
Reverse proxy configurations (Nginx / Cloudflare caching rules).
Zero Monthly GGR Fees: Eliminate ongoing provider commission cuts and retain 100% of player turnover.
Complete Math & RTP Sovereignty: Adjust RTP profiles (e.g., 92% to 98%), customize hit frequency on bonus features, or fine-tune maximum win caps.
Total Reskinning Freedom: Rebrand game skins, update symbol artwork, swap sound libraries, or build brand-new original titles off our stable core engine.
Data Privacy & Regulatory Independence: Host backend services strictly within designated national boundaries to satisfy local data residency requirements.
[ PLAYER BROWSER / MOBILE APP ]
|
+---------------------+---------------------+
| |
v v
[ Hosted API Model ] [ Source Code Model ]
+------------------------------+ +------------------------------+
| * Game served from our CDN | | * Self-hosted on your CDN |
| * Math runs on our servers | | * Math runs on your clusters |
| * Webhooks sent to your host | | * Internal wallet adapter |
| * Revenue share applies | | * 0% GGR / 100% margin |
+------------------------------+ +------------------------------+
| |
+---------------------+---------------------+
|
v
[ OPERATOR CORE PLATFORM ]
(User Balance & Accounting) Sandbox Credentials Issued: Receive test environment credentials and initial test balance within hours.
Webhook Verification: Implement and validate the Seamless Wallet callback loop (debit/credit/rollback).
Staging Certification: Run our automated integration test suite to verify idempotency and edge-case handling.
Production Go-Live: Whitelist production IPs and switch endpoints to live environments.
License & Escrow Agreement: Execute standard intellectual property transfer or non-exclusive perpetual licensing contracts.
Repository Access: Private Git repository access granted with complete build instructions.
Deployment Walkthrough: Dedicated technical consultation with our lead game architects to assist with initial build scripts, Docker orchestration, and database setup.
Knowledge Transfer: Comprehensive developer orientation covering symbol array configurations, reel strip weighting, and RNG seed integration.
If you still have any doubts or questions or wanna source code / API key then feel free to reach us on telegram @soultrain1960