How can attribution payload tampering be prevented in S2S APIs? A receiver can detect unauthorized modifications to covered request fields by verifying a documented message authentication scheme. Preventing application-level request replays and duplicate conversion credits requires combining timestamp freshness checks, atomic nonce tracking, and persistent business-level idempotency.
An Application Programming Interface (API) is a defined interface through which software components exchange data or request functionality. In mobile attribution, HTTP-based APIs enable measurement platforms and advertising networks to exchange conversion data through server-to-server (S2S) postbacks. Securing these interfaces requires validating message integrity, enforcing request freshness, and maintaining persistent business deduplication.
| Term | Definition | Related Entity | Search Intent Role |
|---|---|---|---|
| S2S Postback | An event-driven HTTP request conveying conversion data between backend servers. | Webhook Callback | Technical / Informational |
| Message Authentication Code | A cryptographic checksum generated with a secret key to verify data integrity and authenticity. | HMAC-SHA256 | Technical / Security |
| Replay Defense | Mechanisms preventing intercepted authentic requests from being reprocessed fraudulently. | Nonce Tracking | Technical / Security |
| Business Idempotency | Processing logic ensuring that duplicate transmissions of the same event do not trigger multiple credits. | Event Deduplication | Technical / Architectural |
Primary Threat Vectors Confronting Attribution Postback Endpoints
The Financial Incentive of Conversion Spoofing
In mobile performance marketing, downstream conversion records directly drive financial settlement. High Cost-Per-Acquisition (CPA) campaigns, in-app deposits, and subscription events determine publisher payouts and feed automated ad network optimization models.
Because downstream systems trigger billing and credit allocation based on incoming postback notifications, adversaries have an incentive to manipulate conversion attributes. Without cryptographic payload verification at the application layer, an actor capable of transmitting valid HTTP requests could alter conversion values, redirect partner IDs, or forge non-existent purchase events.
Interception, Modification, and Intermediary Exposure
Transport Layer Security (TLS) protects data in transit between immediate TCP communication peers. However, in modern cloud architectures, TLS is frequently terminated at edge load balancers, API gateways, reverse proxies, or content delivery networks (CDNs) before the request reaches the backend service.
If an intermediate proxy is compromised or an unvetted routing service sits between sender and receiver, incoming request components can be inspected or modified:
- Attribution Rerouting: Altering parameters such as
click_idorpublisher_idto attribute an organic conversion to an unauthorized account. - Monetary Inflation: Altering transaction numbers or currency codes within the request body to claim inflated affiliate commissions.
- Event Elevation: Modifying event category identifiers from top-of-funnel interactions to high-value purchase milestones.
Replay Exploits versus Duplicate Network Deliveries
A replay exploit occurs when an adversary captures an authentic postback transmission and re-submits that exact payload to the receiver. Because the parameters and cryptographic tokens within the original message were authentic when generated, naive receivers that verify only the message signature will evaluate re-submitted requests as valid.
This threat must be distinguished from normal transport-layer retries. Transient network timeouts often cause a sender to retransmit a postback when an HTTP acknowledgment is not received, even though the receiver may have already ingested the record. Robust architectures must differentiate between fraudulent replays and benign redeliveries.
Credential Harvesting and the Limits of Static Tokens
Relying solely on static credentials—such as shared API keys or bearer tokens placed in HTTP request headers—authenticates the caller’s identity under the assumption that the secret remains confidential.
However, static bearer tokens provide zero cryptographic binding to the request body. If a static key is leaked through server logs, repository misconfigurations, or network monitoring tools, an attacker holding that token can forge arbitrary payloads. A static token validates who is claimed to be calling, but does not prove whether the transmitted data was modified.
Cryptographic Message Authentication and the Scope of Protection
Mathematical Mechanism of HMAC (IETF RFC 2104)
A Keyed-Hash Message Authentication Code (HMAC), standardized in IETF RFC 2104, uses a cryptographic hash function (such as SHA-256) combined with a pre-shared secret key to verify data integrity and authenticity.
The HMAC algorithm operates on a secret key
Where:
H is the underlying cryptographic hash function (SHA-256).B is the block size of the hash function (64 bytes for SHA-256).K' is derived from the secret keyK : ifK is longer thanB , it is pre-hashed usingH to lengthL (32 bytes) and padded with zeros toB ; ifK is shorter thanB , it is padded with zeros up toB .\text{opad} is the outer padding string (0x5crepeatedB times).\text{ipad} is the inner padding string (0x36repeatedB times).\parallel denotes byte concatenation, and\oplus denotes bitwise exclusive-OR.
Although industry documentation frequently refers to this mechanism as a “request signature,” HMAC is a symmetric Message Authentication Code (MAC). It does not provide asymmetric digital signatures or cryptographic non-repudiation, because both the sender and the receiver share access to the same secret key
Scope and Boundaries of Message Authentication
Establishing clear boundaries around cryptographic verification prevents overstating security outcomes:
| Verification Boundary | Factual Operational Capability |
|---|---|
| What a Valid MAC Proves | 1. The covered message elements match the exact bytes hashed by the sender. 2. The party generating the MAC possessed the active shared secret key. |
| What a Valid MAC Does Not Prove | 1. That the in-app purchase or install actually occurred on a real device. 2. That the sender did not manufacture fraudulent business events. 3. That the shared secret has not been exposed or shared internally. 4. That the request has not been intercepted and retransmitted (replay). |
A valid MAC authenticates covered request data under the configured key. It does not establish that the reported conversion occurred; authoritative business records, authorization, reconciliation, and event idempotency remain separate controls.
Transport Security versus Application Security

Application-layer message authentication does not replace Transport Layer Security (TLS). TLS operating between immediate TCP peers protects credentials, headers, and payloads from passive wiretapping on the open internet. In turn, application-layer message authentication ensures that even if TLS terminates at an intermediate reverse proxy or edge gateway, unauthorized modifications to covered fields can be detected and rejected before reaching application execution logic.
Construction of the Signed Canonical Data Model
The Risk of Uncovered Request Fields
A cryptographic MAC protects only the specific byte sequence fed into the hash function. As formalized in IETF RFC 9421 (HTTP Message Signatures), any request component omitted from the signature base can be modified or injected in transit without invalidating the authentication tag.
In HTTP S2S attribution postbacks, omitting the URI path, key identifier, or query parameters allows parameter manipulation while maintaining a valid signature on the request body alone:
- Query String Tampering: In an HTTP GET postback, or a POST request carrying URL query parameters, leaving query parameters out of the canonical string permits an adversary to modify those query parameters freely.
- Path Traversal and Endpoint Re-targeting: Omitting the target path allows an adversary to take a payload intended for a test endpoint (
/v1/test/conversion) and forward it to a production billing endpoint (/v1/live/conversion). - Key Identifier Substitution: Omitting the key ID allows an adversary to re-route requests if key lookup and tenant identity are not securely bound, or if the same secret material is inappropriately shared across tenant scopes.
Defining an Illustrative S2S Request Schema
To standardize verification, systems must establish a clear canonical string format. The following schema illustrates a JSON POST conversion payload with dedicated transaction identifiers and optional monetary tracking parameters:
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "IllustrativeConversionPostbackPayload",
"type": "object",
"required": [
"event_id",
"event_name",
"event_timestamp"
],
"properties": {
"event_id": {
"type": "string",
"minLength": 1,
"description": "Unique transaction event identifier used by receiving systems for business-level deduplication."
},
"click_id": {
"type": ["string", "null"],
"description": "Stateless attribution identifier matching an ad click record. Nullable for organic or aggregate events."
},
"campaign_id": {
"type": ["string", "null"],
"description": "Campaign tracking identifier provided during initial click ingestion."
},
"event_name": {
"type": "string",
"minLength": 1,
"description": "Standardized event identifier (e.g., install, purchase, registration)."
},
"event_timestamp": {
"type": "integer",
"minimum": 0,
"description": "Epoch timestamp in whole seconds representing when the business event occurred."
},
"conversion_value": {
"type": "number",
"description": "Optional monetary revenue associated with the event."
},
"currency": {
"type": "string",
"pattern": "^[A-Z]{3}$",
"description": "Three-letter currency formatting string. Semantic validation against ISO 4217 must be enforced by application logic."
}
},
"dependentRequired": {
"conversion_value": ["currency"]
}
}
Canonical Protocol Normalization
To prevent verification failures caused by formatting variations across systems, both sender and receiver must assemble a normalized, delimited UTF-8 string.
Protocol Boundary Note: The following construction defines an illustrative, application-defined MAC profile for JSON POST requests targeting an exact path. It is not the formal IETF RFC 9421 HTTP Message Signatures wire specification or an official OpoInstall protocol. Integrators must document and enforce their own canonicalization rules.
CanonicalString = HTTP_METHOD + "\n" +
REQUEST_PATH + "\n" +
KEY_ID + "\n" +
TIMESTAMP_SECONDS + "\n" +
NONCE + "\n" +
HEX_SHA256(RAW_BODY_BYTES)
Rules for assembling each canonical component in this profile:
HTTP_METHOD: Must be strictly uppercasePOST.REQUEST_PATH: The exact target URI path (e.g.,/v1/conversions/postback). To eliminate query-normalization ambiguity, URL query parameters are disallowed on this endpoint.KEY_ID: The identifier of the pre-shared key (e.g.,key_demo_2026). Bound directly into the canonical string to prevent key-substitution attacks.TIMESTAMP_SECONDS: The request dispatch timestamp formatted as a base-10 integer representing epoch seconds.NONCE: A cryptographically random hexadecimal string (minimum 32 lowercase hex characters, generated via a CSPRNG) unique to this HTTP request dispatch.RAW_BODY_BYTES: The exact byte stream of the request body. The SHA-256 digest is calculated directly over these bytes.

Multi-Layer Replay Defense and Idempotency
Responsibilities Across the Request Verification Pipeline
| Processing Stage | Defensive Control | Operational Responsibility |
|---|---|---|
| 1. Request Transport & Syntax | Method, Path, and Body Size Limits | Validates that the request matches the allowed HTTP method, path, and does not exceed memory boundaries. |
| 2. Freshness Verification | Bounded Timestamp Window ( |
Accepts only timestamps within |
| 3. Identity & Key Binding | Trusted Key Registry Lookup | Resolves the shared secret key from a trusted backend store using X-Key-Id. Rejects unknown keys before cryptographic evaluation. |
| 4. Message Authentication | Constant-Time HMAC-SHA256 Validation | Computes the MAC over the canonical string and compares it against X-Signature using compare_digest. |
| 5. Atomic Replay Protection | Scoped Nonce Cache (SET key NX EX) |
Atomically reserves the nonce in cache under the authenticated tenant key scope for the retention window. |
| 6. Business Deduplication | Transactional Database Unique Constraint | Prevents duplicate credits when event deduplication and credit updates are committed atomically within tenant boundaries. |
Timestamp Drift Tolerances and Nonce Retention Configuration
Mitigating replay exploits requires coordinating two interdependent checks: a bounded timestamp window and an atomic nonce cache.
Consider an integration with a symmetric clock drift tolerance
If a request timestamped at
To prevent this exploit under a symmetric window, this illustrative protocol adopts a conservative retention configuration:
For a tolerance window

Atomic Nonce Tracking and Failure Mode Policies
The nonce check and nonce reservation must execute as an atomic operation. Performing a separate read query followed by a write query introduces a race condition (time-of-check to time-of-use) that permits concurrent replay attacks.
In distributed architectures, atomic reservation is implemented using memory datastore primitives, such as Redis SET key value EX ttl NX. To prevent cross-tenant collision or cross-key pollution, the cache key must be scoped by the authenticated key or tenant identifier (e.g., s2s_nonce:{key_id}:{nonce}).
System administrators must define explicit failure policies for when the distributed cache is unreachable:
- Fail-Closed Policy: Rejects incoming postbacks with an HTTP 503 status if the nonce cache is offline. This prevents replay attacks during infrastructure partitions but halts conversion ingestion.
- Fail-Open Policy with Auditing: Temporarily allows verified signatures through while logging an alert. This preserves ingestion availability, but operators must accept that transport replay protection is downgraded until the cache recovers.
Transport Replays versus Business Idempotency
Application security must decouple transport-layer retry handling from business-layer event processing:
- Transport Layer (Nonce & Timestamp): Secures a single HTTP dispatch. If a network timeout occurs and the sender retries the postback, the sender must generate a new timestamp, a new nonce, and recompute the HMAC over the updated canonical string.
- Business Layer (Event ID): Secures the conversion record. The payload body retains the original, immutable
event_id. When the receiving ad network ingests the request, it checks whetherevent_idhas already been credited within a persistent database transaction (e.g., via anINSERT ... ON CONFLICT DO NOTHINGunique constraint scoped to the tenant). If already processed, it returns an acknowledgment without duplicate billing.

Reference Implementation: Cryptographic Header Schema and Verification
Wire-Level Header and Payload Representation
The following self-consistent HTTP exchange illustrates an authenticated conversion postback request utilizing decoupled cryptographic headers.
The request uses the test secret key b"k_demo_secret_key_32_bytes_len!", X-Key-Id key_demo_2026, timestamp 1794815760 (corresponding to 2026-11-16T07:56:00Z), and nonce 4e9a2c1b74e64f8e9b2a1c74e6f8a9b2.
The raw UTF-8 body bytes (compact JSON, exactly 207 bytes) are:
{"event_id":"evt_9876543210_abc","click_id":"click_123456789_xyz","campaign_id":"cmp_spring_acquisition","event_name":"in_app_purchase","event_timestamp":1794815758,"conversion_value":49.99,"currency":"USD"}
Calculating SHA-256(raw_body_bytes) yields:
eda92f236690851c47e5662feb02a6d3aa144e6d7061bf41c4b41a4f43a0a9ba
Assembling the canonical string:
POST
/v1/conversions/postback
key_demo_2026
1794815760
4e9a2c1b74e64f8e9b2a1c74e6f8a9b2
eda92f236690851c47e5662feb02a6d3aa144e6d7061bf41c4b41a4f43a0a9ba
Calculating HMAC-SHA256(key, canonical_string) yields the exact hex signature:
a0c399934b8bde268d5deedb879b2f06ff8d9df0b51dd5957fd1014a8e1429fc
The wire transmission and immediate acknowledgment:
POST /v1/conversions/postback HTTP/1.1
Host: api.adnetwork-receiver.example.com
Content-Type: application/json
X-Key-Id: key_demo_2026
X-Signature-Version: v1
X-Timestamp: 1794815760
X-Nonce: 4e9a2c1b74e64f8e9b2a1c74e6f8a9b2
X-Signature: a0c399934b8bde268d5deedb879b2f06ff8d9df0b51dd5957fd1014a8e1429fc
{"event_id":"evt_9876543210_abc","click_id":"click_123456789_xyz","campaign_id":"cmp_spring_acquisition","event_name":"in_app_purchase","event_timestamp":1794815758,"conversion_value":49.99,"currency":"USD"}
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 16 Nov 2026 07:56:01 GMT
{
"status": "acknowledged",
"event_id": "evt_9876543210_abc"
}
Defensive Verification Logic in Python
The following implementation represents an authentication-layer reference component. Note that request_target must be extracted directly from the raw HTTP request line, preserving any path and query elements so that unauthorized query strings are rejected. Application-layer concerns—such as Content-Type validation, tenant authorization, and schema deserialization—must be evaluated by downstream middleware before transactions are committed:
import hmac
import hashlib
import time
import re
from typing import Optional, Dict
# Configuration Constants
ALLOWED_SIGNATURE_VERSIONS = {"v1"}
HEX_64_PATTERN = re.compile(r"^[0-9a-f]{64}$")
TIMESTAMP_PATTERN = re.compile(r"^\d{1,10}$")
HEX_NONCE_PATTERN = re.compile(r"^[0-9a-f]{32,64}$")
DRIFT_WINDOW_SECONDS = 300
SKEW_MARGIN_SECONDS = 60
NONCE_TTL_SECONDS = (DRIFT_WINDOW_SECONDS * 2) + SKEW_MARGIN_SECONDS
MAX_BODY_SIZE_BYTES = 1024 * 64 # 64 KB limit
EXPECTED_REQUEST_PATH = "/v1/conversions/postback"
# Mock Trusted Key Registry (In production, load securely from Vault / KMS)
TRUSTED_KEY_REGISTRY: Dict[str, bytes] = {
"key_demo_2026": b"k_demo_secret_key_32_bytes_len!"
}
class VerificationResult:
def __init__(self, valid: bool, status_code: int, error_code: str):
self.valid = valid
self.status_code = status_code
self.error_code = error_code
def verify_s2s_postback_authentication(
headers: dict,
http_method: str,
request_target: str,
raw_body_bytes: bytes,
redis_client
) -> VerificationResult:
"""
Reference authentication-layer verifier for S2S postback requests.
Enforces strict method/path rules, validates headers, checks freshness,
verifies HMAC-SHA256, and atomically reserves the scoped nonce in Redis.
"""
# 1. Payload Size Guard
if len(raw_body_bytes) > MAX_BODY_SIZE_BYTES:
return VerificationResult(False, 413, "PAYLOAD_TOO_LARGE")
# 2. Strict Method and Target Path Enforcement (No query strings allowed)
if http_method.upper().strip() != "POST":
return VerificationResult(False, 405, "METHOD_NOT_ALLOWED")
normalized_target = request_target.strip()
if normalized_target != EXPECTED_REQUEST_PATH:
return VerificationResult(False, 404, "INVALID_REQUEST_PATH")
# 3. Header Extraction and Syntax Validation
sig_version = headers.get("X-Signature-Version", "")
if sig_version not in ALLOWED_SIGNATURE_VERSIONS:
return VerificationResult(False, 400, "UNSUPPORTED_SIGNATURE_VERSION")
key_id = headers.get("X-Key-Id", "").strip()
if not key_id or len(key_id) > 64 or not key_id.isascii():
return VerificationResult(False, 400, "INVALID_KEY_ID_FORMAT")
# 4. Resolve Trusted Secret Key from Authenticated Registry
secret_key = TRUSTED_KEY_REGISTRY.get(key_id)
if not secret_key:
return VerificationResult(False, 401, "UNKNOWN_OR_INACTIVE_KEY")
received_sig = headers.get("X-Signature", "").strip().lower()
if not received_sig.isascii() or not HEX_64_PATTERN.match(received_sig):
return VerificationResult(False, 400, "MALFORMED_SIGNATURE_HEADER")
timestamp_str = headers.get("X-Timestamp", "").strip()
if not timestamp_str.isascii() or not TIMESTAMP_PATTERN.match(timestamp_str):
return VerificationResult(False, 400, "MALFORMED_TIMESTAMP_HEADER")
nonce = headers.get("X-Nonce", "").strip().lower()
if not nonce.isascii() or not HEX_NONCE_PATTERN.match(nonce):
return VerificationResult(False, 400, "INVALID_NONCE_FORMAT")
# 5. Time-Drift Freshness Check
req_timestamp = int(timestamp_str)
current_time = int(time.time())
if abs(current_time - req_timestamp) > DRIFT_WINDOW_SECONDS:
return VerificationResult(False, 401, "EXPIRED_OR_PREDATED_TIMESTAMP")
# 6. Canonical String Construction (Explicitly binding Method, Path, Key ID, Timestamp, Nonce, Body)
body_digest = hashlib.sha256(raw_body_bytes).hexdigest()
canonical_string = (
f"POST\n"
f"{EXPECTED_REQUEST_PATH}\n"
f"{key_id}\n"
f"{timestamp_str}\n"
f"{nonce}\n"
f"{body_digest}"
)
# 7. Cryptographic MAC Calculation (RFC 2104 / SHA-256)
computed_mac = hmac.new(
secret_key,
canonical_string.encode("utf-8"),
hashlib.sha256
).hexdigest()
# Constant-time comparison to mitigate timing attacks
if not hmac.compare_digest(received_sig, computed_mac):
return VerificationResult(False, 401, "SIGNATURE_VERIFICATION_FAILED")
# 8. Scoped Atomic Nonce Registration (Bound to Key ID; executed AFTER signature check)
scoped_nonce_key = f"s2s_nonce:{key_id}:{nonce}"
try:
is_unique = redis_client.set(
scoped_nonce_key,
"1",
ex=NONCE_TTL_SECONDS,
nx=True
)
if not is_unique:
return VerificationResult(False, 401, "REPLAYED_TRANSACTION_NONCE")
except Exception:
# Fail-closed policy: reject request when nonce storage is unavailable
return VerificationResult(False, 503, "NONCE_STORAGE_UNAVAILABLE")
return VerificationResult(True, 200, "SUCCESS")
HTTP Status Code Semantics for Security Verification Failures
Standardizing HTTP status responses enables diagnostic auditing while adhering to protocol standards:
400 Bad Request: Indicates syntactic or structural malformations in the request transmission. Returned when mandatory security headers are absent, string encoding violates ASCII rules, or hexadecimal values violate format patterns.401 Unauthorized: Indicates authentication or cryptographic failure. Returned when the key ID is unrecognized, the HMAC computation does not match the incoming signature, the timestamp violates drift bounds, or the nonce is identified as a duplicate. When generating a 401 response, the HTTP adapter layer must include an applicableWWW-Authenticatechallenge header conforming to IETF RFC 9110.403 Forbidden: Indicates that while the cryptographic signature and timestamp verified successfully under the key, the authenticated tenant lacks permissions for the specific campaign or publisher resources identified in the body.405 Method Not Allowed: Returned when the request uses an unsupported HTTP verb (e.g.,GETorPUTon an endpoint configured exclusively for signedPOSTrequests). The HTTP adapter layer should include anAllow: POSTheader in the response.413 Payload Too Large: Returned when the request body exceeds the configured maximum byte limit (e.g., 64 KB).422 Unprocessable Content: Indicates that while cryptographic headers verified successfully, the JSON payload body violates semantic rules (for example, missing a required ISO currency code when an event revenue value is passed).
Comparative Evaluation of S2S Security Controls
Selecting appropriate security mechanisms requires evaluating defense layers against specific operational boundaries:
| Control | TLS Connection Security | Application Payload Integrity | Application Request Replay Defense | Business Event Deduplication |
|---|---|---|---|---|
| Static Bearer Token over HTTPS | Provided by TLS between immediate peers | None; payload unprotected across intermediate proxies | None; bearer tokens replayable within validity period | Requires separate database unique constraint |
| IP Allowlisting | None; network routing control only | None; packets unauthenticated at application layer | None; requests replayable from authorized IPs | Requires separate database unique constraint |
| Application HMAC-SHA256 | None; operates at application layer | Authenticates covered canonical elements under the key | Dependent on external timestamp and nonce mechanisms | Requires separate database unique constraint |
| Mutual TLS (mTLS) | Cryptographic peer and transport authentication | Tunnel-level; does not protect against application-level replays | None; requests replayable at application layer | Requires separate database unique constraint |
| Layered Architecture (mTLS + HMAC + Nonce + DB Unique Key) | Cryptographic peer authentication across network | End-to-end payload integrity across intermediaries | Enforced via timestamp bounds and atomic nonce cache | Enforced via transactional database constraints |
Frequently Asked Questions (FAQ)
What is the difference between an API key and an HMAC signature in S2S security?
How do receiving systems handle legitimate clock drift during postback validation?
Why is IP allowlisting insufficient as a standalone security control for attribution APIs?
Summary and Decision Framework
Preventing attribution payload tampering in Server-to-Server APIs requires moving beyond static credentials and unauthenticated webhooks. By implementing an application-layer cryptographic architecture that combines canonical string normalization, HMAC-SHA256 hashing, bounded timestamp checks, and atomic nonce reservation, measurement systems establish verifiable data integrity and mitigate replay exploits.
Cryptographic validation confirms that incoming conversion data matches the exact payload constructed by the sender holding the pre-shared secret. However, message authentication does not verify underlying real-world conversion legitimacy. Enterprise attribution architectures must pair request signing with business-level idempotency, conversion value auditing, and server-side reconciliation to maintain resilient attribution systems.
Teams preparing to configure campaign tracking integrations and review API specifications can consult the OpoInstall documentation center, manage application identifiers on the OpoInstall developer console, or examine the broader mobile attribution implementation reference for architectural guidance.
Related Materials
-
Concepts: API Definition, HMAC-SHA256, Replay Attack Defense, Cryptographic Nonce, Canonical Request, Business Idempotency
-
Technologies: RESTful Web Services, HTTPS over TLS, Keyed-Hash Message Authentication, Distributed In-Memory Caching
-
Standards: IETF RFC 2104 HMAC Standard, IETF RFC 9110 HTTP Semantics, IETF RFC 9421 HTTP Message Signatures, JSON Schema Draft 2020-12
-
APIs: Meta Conversions API Authentication, Google Ads Offline Conversion Security Protocols, Webhook HMAC Verification Interfaces
-
Official Documentation & References:
Share this article



