pg soft api: Apply Self-Exclusion to Active Sessions

A pg soft api integration should enforce self-exclusion even when a player already has a game open. Blocking the casino lobby is not enough: an existing session may remain connected, another browser tab may hold a launch URL, and wallet requests may arrive after the account becomes restricted. Operators need an acceptance plan that stops new gambling without losing legitimate settlement records or making winnings inaccessible.

This guide focuses on that boundary. It does not assume PG Soft exposes particular exclusion endpoints, callback fields, or session-termination features. Confirm those capabilities with your contracted integration partner and assess the implementation against the rules applicable to your operation.

Why blocking the lobby is insufficient

Consider a player who opens a game on a phone, then activates self-exclusion through the casino website on a laptop. The website confirms the restriction, but the phone still shows the game. If the wallet service checks only the session's original eligibility, another wager could be accepted.

The failure is architectural: account restrictions are enforced at navigation time rather than at the point where gambling is authorized.

A reliable design separates three decisions:

• Launch eligibility: may this account open or resume a game?
• Wager eligibility: may this request create new gambling exposure?
• Settlement handling: does this message resolve an obligation already created?

Those decisions must reference the same authoritative account status, but they should not automatically produce the same response.

Define the pg soft api exclusion boundary

Before implementation, agree where restrictions are stored, checked, and propagated. In an aggregated integration, the operator, aggregator, and studio may each control a different part of the session lifecycle.

Create a responsibility map covering:

• The system that records self-exclusion and its effective timestamp.
• The service that authorizes game launches and reconnects.
• The component that approves wallet debits.
• Any supported mechanism for terminating active provider sessions.
• The team responsible for unresolved rounds and disputed transactions.

Obtain the documented behavior for restriction-related wallet responses. Do not invent an error code and assume the game will stop cleanly. Ask whether the mapped response stops play, triggers retries, or leaves the interface waiting.

Also confirm the contractual route, permitted markets, and actual PG Soft titles available to your business. Access to an aggregation API does not itself establish permission to distribute every studio's games in every jurisdiction.

Make restriction changes authoritative

Record the state transition durably

Store the exclusion state with an effective time, scope, source, and audit identifier. Scope matters: a restriction might apply to one brand, multiple brands, or a broader scheme, depending on the applicable requirements and your operating structure.

The confirmation shown to the player should correspond to a durable state change, not merely a queued request. If external propagation is asynchronous, distinguish that propagation from the local controls that must already prevent new gambling.

Do not copy sensitive exclusion details into every game request. Most downstream checks need an eligibility decision and a reference to the authoritative restriction, not the player's full support history.

Enforce the state at wager authorization

In a seamless-wallet model, the debit authorization path is a critical enforcement point. It should check current eligibility rather than trusting a flag captured when the game launched.

A simple read followed by a separate debit can still race with an exclusion update. Use an appropriate serialization or concurrency-control mechanism so restriction activation and new-wager authorization have a defined order. Document what constitutes acceptance in your architecture; callback arrival time alone may not establish when an obligation arose.

If authoritative eligibility cannot be established, do not default to permitting new gambling. Define separate recovery behavior for settlement processing so an eligibility outage does not silently discard valid credits.

Stop new play without breaking settlement

A blanket rejection of every message after exclusion can create incorrect balances. The wallet must distinguish new exposure from the resolution of existing obligations using the documented transaction model.

Classify requests by financial purpose

Build a reviewed decision table for at least these cases:

• New wager: reject when the account is no longer eligible.
• Retry of an already processed wager: return the documented idempotent result without applying another debit.
• Win from a previously accepted wager: process according to the established settlement contract and applicable rules.
• Reversal or refund: validate the original transaction relationship and apply the correct ledger treatment once.
• Unrecognized transaction: hold for investigation or use the documented unresolved-transaction workflow; never guess its meaning.

Do not infer transaction purpose solely from a positive or negative amount. Use the provider or aggregator's documented message types, identifiers, and transaction relationships.

Some game features may require further player interaction after an initial wager. Ask how those states behave under exclusion, including whether any action creates additional exposure. Obtain an approved resolution procedure rather than assuming continued interactive play is permissible.

Define the cutover rule

For near-simultaneous exclusion and betting events, preserve evidence of the actual authorization sequence. Operator timestamps, provider timestamps, and network arrival times can differ.

Your compliance and integration teams should approve how disputed boundary cases are investigated. A locally recorded acceptance order is useful evidence, but it must be interpreted alongside the contractual transaction model and applicable requirements.

Test every route back into the game

Session termination is helpful where supported, but it is not a substitute for wallet enforcement. A disconnect signal may be delayed, and a player may still have another active session.

Include these acceptance tests:

• Activate exclusion while a game is open and attempt another wager.
• Activate exclusion on one device while playing on another.
• Reuse an earlier launch URL after the restriction takes effect.
• Reconnect through the game's own recovery behavior.
• Attempt a fresh launch through a direct route that bypasses the lobby.
• Deliver a valid settlement after exclusion and verify ledger handling.
• Retry an already accepted debit and confirm no additional money moves.
• Interrupt restriction-event delivery and verify authoritative checks still operate.

For each test, capture the restriction reference, account scope, session reference, transaction identifiers, eligibility decision, and ledger outcome. Use synthetic accounts in an approved test environment rather than exposing real excluded players to testing.

Give support a usable incident procedure

When a restricted player reports that a game remains visible, support should not equate visibility with successful betting. The first task is to establish whether any new wager was accepted after the relevant restriction boundary.

A concise runbook should tell staff how to:

1. Confirm the authoritative exclusion state and scope.
2. Identify active sessions and apply supported termination controls.
3. Inspect debit decisions and linked settlement records.
4. Escalate any accepted post-restriction wager to compliance and engineering.
5. Communicate account access, balance, and withdrawal arrangements accurately.

Self-exclusion should not be treated as permission to confiscate funds or conceal settlement information. Withdrawal handling remains subject to applicable rules and legitimate verification requirements.

Monitor accepted wagers against restriction records and investigate exceptions. Restrict access to this monitoring data and avoid placing launch tokens or unnecessary personal information in incident logs.

Set the commercial and technical acceptance gate

GamingAPI offers 16,000+ games from 150+ studios through one API, with a seamless wallet, multi-currency support, and USDT deposits. Those platform features do not replace your self-exclusion obligations or prove a particular studio's session-control behavior.

Before signing off, request confirmation of PG Soft availability for your intended markets, the relevant wallet response mapping, active-session controls, and escalation ownership through contact.

GamingAPI's stated pricing is $350 one-time setup plus 10% of positive GGR. Review pricing alongside the agreement and scope any custom restriction workflows explicitly. Launch approval should depend on demonstrated controls, not simply a successful game launch or balance check.

FAQ

Is blocking new game launches enough?

No. An existing game session may still submit wagers. Enforce current eligibility in the wager-authorization path and use supported session-termination controls as an additional measure.

Should all wallet callbacks be rejected after self-exclusion?

No. New wagers and valid settlements have different purposes. Classify each message using the documented transaction model, preserve idempotency, and handle existing obligations under the applicable contract and rules.

Can an aggregator handle self-exclusion for the operator?

An aggregator may provide useful controls, but responsibilities must be explicit. Verify restriction propagation, enforcement points, failure behavior, and evidence access. The operator still needs an approved policy and acceptance tests for its own account and wallet systems.