Guides
SMPP v3.4 Integration Guide
A developer guide to connecting an application to an SMPP v3.4 SMS gateway: binds, submission, delivery receipts, encoding, keepalives, reconnection and throttling, with a tested generic Node.js client.
- Author
- By TXTPro Editorial Team
- Published
- Reading time
- 18 min read
SMPP architecture overview
SMPP defines two roles. Your application is the ESME (External Short Messaging Entity); the provider’s gateway is the SMSC or message centre. The ESME opens a TCP connection to the SMSC, binds to start a session, and then exchanges PDUs (protocol data units): requests such as submit_sm and the matching responses such as submit_sm_resp.
Sessions are long-lived and asynchronous. Your client can send several requests without waiting for each response, matching responses by sequence number, and the SMSC can send requests to you at any time, most often deliver_sm carrying delivery receipts. The TXTPro SMPP account page summarises the confirmed service capabilities.
Prerequisites for integration
- An SMPP account with the connection details shared during onboarding: host, port, system ID, password and bind type.
- A server or NAT gateway with a fixed public IP address registered for IP whitelisting.
- DLT registration for your SMS traffic: Principal Entity, headers and approved templates. See the DLT registration guide.
- An SMPP v3.4 client: an existing gateway or platform connector, or a library in your language.
- A store for outbound messages and their status, keyed by your own reference and the SMSC message ID.
SMPP v3.4 client requirements
Whichever client you use, check that it can:
- bind as transceiver, transmitter or receiver, and send
interface_version0x34; - keep several requests in flight and match responses by
sequence_number; - answer
deliver_smandenquire_linkfrom the SMSC promptly; - send its own
enquire_linkkeepalives and detect a dead link; - encode text as GSM 7-bit or UCS-2 and set
data_codingcorrectly; - reconnect automatically and pace submissions to a configured rate.
The examples below use @semyonf/smpp, a maintained, MIT-licensed fork of the widely used node-smpp library. It implements SMPP v5.0, which is backward compatible with v3.4, and it defaults to interface_version 0x50, so v3.4 binds must set 0x34 explicitly.
Connection establishment
The client opens a TCP connection to the host and port from your onboarding details, then sends a bind request as its first PDU. IANA registers port 2775 for SMPP, but providers often use other ports, so use only the values you were given. Until the bind succeeds, the SMSC will reject other requests.
Set a connect timeout (for example 15 seconds) so a blocked or unreachable connection fails fast and your reconnection logic takes over, rather than hanging indefinitely.
IP whitelisting
TXTPro accepts SMPP connections only from the public IP addresses registered for your account. Provide every address your clients connect from, including standby servers and the egress IP of any NAT gateway or cloud firewall. A connection from an unregistered address is refused, which typically shows up as a refused connection or a failed bind.
Bind types
| Bind | PDU (command ID) | Submit SMS | Receive receipts |
|---|---|---|---|
| Transceiver (TRX) | bind_transceiver (0x00000009) | Yes | Yes |
| Transmitter (TX) | bind_transmitter (0x00000002) | Yes | No |
| Receiver (RX) | bind_receiver (0x00000001) | No | Yes |
TXTPro supports TRX, TX and RX binds, and separate TX + RX sessions. A TX-only bind cannot receive delivery receipts, so pair it with an RX session if you need them.
SMPP authentication
A bind carries system_id (your account identifier), password and, where your provider uses it, system_type. The SMSC answers with a bind response: command_status 0 means the session is bound. Common failures in the specification include ESME_RINVPASWD (0x0E, invalid password), ESME_RINVSYSID (0x0F, invalid system ID), ESME_RBINDFAIL (0x0D, bind failed) and ESME_RALYBND (0x05, already bound).
SMPP v3.4 limits the password to 8 characters and sends it in clear text inside the bind PDU, so treat network access controls and credential handling seriously. Load credentials from environment variables or a secrets manager, never from source code, and do not retry a rejected bind in a tight loop.
TRX session setup
With a transceiver bind, one session submits messages and receives receipts. It is the simplest arrangement to operate and monitor.
// TRX: one session for submission and delivery receipts.
session.bind_transceiver(
{ system_id: process.env.SMPP_SYSTEM_ID, password: process.env.SMPP_PASSWORD, interface_version: 0x34 },
(pdu) => console.info('bind_transceiver status', pdu.command_status),
);TX/RX session setup
With separate sessions, the transmitter submits and the receiver gets deliver_sm. Bind both with the same credentials unless your onboarding details say otherwise, and monitor and reconnect each session independently: a healthy TX session does not mean receipts are flowing.
// Separate TX + RX: two connections with the same credentials.
const options = { url: `smpp://${process.env.SMPP_HOST}:${process.env.SMPP_PORT}`, auto_enquire_link_period: 30_000 };
const credentials = { system_id: process.env.SMPP_SYSTEM_ID, password: process.env.SMPP_PASSWORD, interface_version: 0x34 };
const tx = smpp.connect(options, () => tx.bind_transmitter(credentials, (pdu) => console.info('TX bind', pdu.command_status)));
const rx = smpp.connect(options, () => rx.bind_receiver(credentials, (pdu) => console.info('RX bind', pdu.command_status)));
// Submit on TX; delivery receipts arrive on RX.
rx.on('deliver_sm', (pdu) => rx.send(pdu.response()));Complete generic client example
mkdir smpp-client && cd smpp-client
npm init -y
npm install @semyonf/smpp
# Create .env and smpp-client.mjs as shown below, then:
node --env-file=.env smpp-client.mjs# .env: keep out of version control. Values are shared during onboarding.
SMPP_HOST=replace-with-host-from-onboarding
SMPP_PORT=replace-with-port-from-onboarding
SMPP_SYSTEM_ID=replace-with-system-id
SMPP_PASSWORD=replace-with-password
# trx | tx | rx | tx-rx (two sessions: TX for submission, RX for receipts)
SMPP_BIND_TYPE=trx
# Your DLT-registered header, and a rate below your configured TPS
SMPP_SOURCE_ADDR=replace-with-registered-header
SMPP_MAX_TPS=5// smpp-client.mjs: generic SMPP v3.4 client (TRX, TX, RX or separate TX + RX).
// Requires Node.js 22+ and: npm install @semyonf/smpp
//
// GENERIC INTEGRATION SAMPLE, not a TXTPro-specific configuration. Before using it with a
// TXTPro account, confirm the host, port, system_type, bind type, TON/NPI, source address
// rules, DLT parameters, configured TPS and delivery receipt format during onboarding.
import smpp from '@semyonf/smpp';
const { SMPP_HOST, SMPP_PORT, SMPP_SYSTEM_ID, SMPP_PASSWORD } = process.env;
const BIND_TYPE = (process.env.SMPP_BIND_TYPE || '').toLowerCase();
const SESSIONS = { trx: ['transceiver'], tx: ['transmitter'], rx: ['receiver'], 'tx-rx': ['transmitter', 'receiver'] };
if (!SMPP_HOST || !SMPP_PORT || !SMPP_SYSTEM_ID || !SMPP_PASSWORD || !SESSIONS[BIND_TYPE]) {
// Fail closed: never fall back to default hosts or credentials.
console.error('Missing SMPP_HOST, SMPP_PORT, SMPP_SYSTEM_ID, SMPP_PASSWORD or SMPP_BIND_TYPE (trx, tx, rx, tx-rx). Refusing to start.');
process.exit(1);
}
const SOURCE_ADDR = process.env.SMPP_SOURCE_ADDR || '';
const MAX_TPS = Math.max(1, Number(process.env.SMPP_MAX_TPS) || 1);
const RECEIPT_FIELDS = /\b(id|sub|dlvrd|submit date|done date|stat|err):(\S*)/gi;
const outbox = []; // messages waiting for submission: { ref, to, text }
const sentByMessageId = new Map(); // SMSC message_id -> your reference
let stopping = false;
let pausedUntil = 0;
function openSession(mode) {
const state = { mode, bound: false, fatal: false, attempt: 0 };
state.session = smpp.connect(
{
url: `smpp://${SMPP_HOST}:${SMPP_PORT}`,
connectTimeout: 15_000,
response_timeout: 30_000,
auto_enquire_link_period: 30_000, // keepalive
enquire_link_timeout: 10_000, // drop a dead link, then reconnect
auto_enquire_link_response: true,
auto_unbind_response: true,
},
() => bind(state),
);
state.session.on('deliver_sm', (pdu) => onDeliverSm(state.session, pdu));
state.session.on('error', (err) => console.error(`${mode} session error`, { code: err.code }));
state.session.on('close', () => {
state.bound = false;
if (stopping || state.fatal) return;
// Exponential backoff with jitter, capped at one minute.
const delay = Math.min(60_000, 1_000 * 2 ** state.attempt++) + Math.floor(Math.random() * 250);
console.warn(`${mode} session closed; reconnecting in ${delay} ms`);
setTimeout(() => state.session.connect(), delay);
});
return state;
}
function bind(state) {
const request = {
system_id: SMPP_SYSTEM_ID,
password: SMPP_PASSWORD,
system_type: process.env.SMPP_SYSTEM_TYPE || '',
interface_version: 0x34, // SMPP v3.4 (this library defaults to 0x50, v5.0)
};
state.session[`bind_${state.mode}`](request, (pdu) => {
if (pdu.command_status !== smpp.ESME_ROK) {
// Wrong credentials or a non-whitelisted IP: stop instead of retrying in a loop.
console.error(`bind_${state.mode} rejected`, { command_status: pdu.command_status });
state.fatal = true;
process.exitCode = 1;
shutdown();
return;
}
state.attempt = 0;
state.bound = true;
console.info(`bound as ${state.mode}`);
});
}
function onDeliverSm(session, pdu) {
session.send(pdu.response()); // acknowledge first, then process
const isReceipt = (pdu.esm_class & 0x3c) === 0x04;
if (!isReceipt) {
console.info('inbound message received'); // route to your MO handling; do not log content
return;
}
const body = pdu.short_message;
const text = typeof body === 'string' ? body : Buffer.isBuffer(body) ? body.toString('latin1') : String(body?.message ?? '');
// The receipt text follows the common SMPP v3.4 Appendix B layout, but the format is
// SMSC-specific: confirm it with your provider. Prefer the receipted_message_id TLV when present.
const fields = Object.fromEntries([...text.matchAll(RECEIPT_FIELDS)].map((m) => [m[1].toLowerCase(), m[2]]));
const messageId = pdu.receipted_message_id || fields.id;
const ref = sentByMessageId.get(messageId);
console.info('delivery receipt', JSON.stringify({ message_id: messageId, ref: ref ?? null, stat: fields.stat ?? null, err: fields.err ?? null }));
// Persist the status against ref in your database here.
}
export function send(to, text, ref) {
outbox.push({ ref, to, text });
}
function submitNext(tx) {
if (!tx?.bound || Date.now() < pausedUntil || outbox.length === 0) return;
const msg = outbox.shift();
tx.session.submit_sm(
{
source_addr: SOURCE_ADDR,
source_addr_ton: 5, // alphanumeric header: confirm TON/NPI with your provider
source_addr_npi: 0,
destination_addr: msg.to, // international format without "+", e.g. 91XXXXXXXXXX
dest_addr_ton: 1,
dest_addr_npi: 1,
registered_delivery: 1, // request a receipt on final success or failure
short_message: msg.text, // the library selects GSM, Latin-1 or UCS-2 and sets data_coding
},
(resp) => {
if (resp.command_status === smpp.ESME_ROK) {
sentByMessageId.set(resp.message_id, msg.ref);
console.info('submitted', JSON.stringify({ ref: msg.ref, message_id: resp.message_id }));
} else if (resp.command_status === smpp.ESME_RTHROTTLED || resp.command_status === smpp.ESME_RMSGQFUL) {
// Throttled: slow down and retry this message first.
outbox.unshift(msg);
pausedUntil = Date.now() + 1_000;
console.warn('throttled; retrying', JSON.stringify({ ref: msg.ref, command_status: resp.command_status }));
} else {
console.error('submit rejected', JSON.stringify({ ref: msg.ref, command_status: resp.command_status }));
}
},
undefined,
(_pdu, err) => {
// No response: the message may or may not have been accepted. Do not resend
// automatically, or it may be delivered twice; reconcile it with a receipt or report.
console.error('submit outcome unknown', JSON.stringify({ ref: msg.ref, code: err?.code ?? 'write_failed' }));
},
);
}
const sessions = SESSIONS[BIND_TYPE].map(openSession);
const tx = sessions.find((s) => s.mode !== 'receiver');
setInterval(() => submitNext(tx), Math.ceil(1_000 / MAX_TPS)); // stay below your configured TPS
if (process.env.SMPP_TEST_DESTINATION && process.env.SMPP_TEST_MESSAGE) {
if (tx) send(process.env.SMPP_TEST_DESTINATION, process.env.SMPP_TEST_MESSAGE, 'test-1');
else console.warn('An RX-only bind cannot submit messages.');
}
function shutdown() {
stopping = true;
for (const s of sessions) {
if (s.bound) s.session.unbind(() => s.session.close());
else s.session.close();
}
setTimeout(() => process.exit(), 2_000).unref();
}
process.on('SIGINT', shutdown);
process.on('SIGTERM', shutdown);
The client supports SMPP_BIND_TYPE values trx, tx, rx and tx-rx, refuses to start without connection settings, requests a delivery receipt on every message, acknowledges each deliver_sm, sends keepalives, reconnects with backoff, stops on a rejected bind and retries throttled submissions. Set SMPP_TEST_DESTINATION and SMPP_TEST_MESSAGE to submit one test message after binding. It is tested against a local mock SMSC; it has not been run against a TXTPro production account.
Sending SMS using submit_sm
submit_sm carries one message. The fields that matter most:
| Parameter | Purpose | Notes |
|---|---|---|
source_addr | Sender (header) | Your DLT-registered header for Indian SMS traffic |
destination_addr | Recipient number | Commonly international format without “+”, e.g. 91XXXXXXXXXX |
source_addr_ton / _npi | Address type of the sender | Alphanumeric headers usually use TON 5, NPI 0 |
dest_addr_ton / _npi | Address type of the recipient | International E.164 numbers usually use TON 1, NPI 1 |
registered_delivery | Delivery receipt request | 1 = receipt on final success or failure |
data_coding | Character encoding | 0 default alphabet, 8 UCS-2 for Unicode |
short_message | Message body | Up to 254 octets; longer text needs multipart handling |
For Indian traffic, DLT entity and template identifiers may need to be passed with each submission, typically in optional parameters, or they may be mapped by the provider. How this works for your account is confirmed during onboarding; the example does not invent parameter tags.
Understanding submit_sm_resp
The SMSC answers each submit_sm with a submit_sm_resp carrying the same sequence_number. A command_status of 0 (ESME_ROK) means the message was accepted for delivery, not delivered, and the response carries the message_id the SMSC assigned (a string of up to 65 characters in v3.4). Any other status means the submission was rejected, for example ESME_RINVDSTADR (0x0B) for an invalid destination address.
If no response arrives within your timeout, the outcome is unknown: the SMSC may have accepted the message. Avoid blind resubmission, which can deliver the message twice; mark it for reconciliation instead.
Receiving DLRs through deliver_sm
When you request a receipt, the SMSC later sends a deliver_sm on your TRX or RX session with the delivery-receipt flag set in esm_class (bits 2–5 equal to 0001, i.e. esm_class & 0x3C === 0x04). Respond with deliver_sm_resp immediately, then process the receipt asynchronously. Unacknowledged receipts may be redelivered or block further delivery.
The receipt text in short_message commonly follows the example in Appendix B of the v3.4 specification, which the specification itself describes as vendor specific:
id:7c2f1a90 sub:001 dlvrd:001 submit date:2611091030 done date:2611091031 stat:DELIVRD err:000 text:Typical stat values include DELIVRD, UNDELIV, EXPIRED, REJECTD, DELETED, ACCEPTD and UNKNOWN. Where present, the receipted_message_id and message_state optional parameters are more reliable than parsing text. Confirm the receipt format for your account during onboarding.
Message ID correlation
Generate your own reference before submission, store it with the destination and template, and record the message_id from submit_sm_resp against it. When a receipt arrives, look the record up by receipted_message_id or the receipt’s id field and update its status.
- Index the SMSC message ID in your database; receipts arrive continuously and must be matched quickly.
- Some SMSCs report the ID in a different format in the receipt (for example decimal instead of hexadecimal). Check one real receipt during testing before relying on string equality.
- Multipart messages produce one message ID, and potentially one receipt, per segment.
- Keep final statuses final: a late interim receipt must not overwrite DELIVRD or UNDELIV.
Registered delivery configuration
| Value | Meaning |
|---|---|
| 0 | No delivery receipt requested |
| 1 | Receipt requested for final delivery success or failure |
| 2 | Receipt requested only for delivery failure |
Set 1 on every message for which you need a status, and make sure the session that will receive it is bound as TRX or RX. Whether receipts are returned also depends on routing and on the receipt configuration for your account.
TON/NPI configuration
Every address carries a Type of Number (TON) and Numbering Plan Indicator (NPI). Mismatched values are a common cause of rejected submissions or altered sender IDs.
| Use | TON | NPI |
|---|---|---|
| Alphanumeric sender header | 5 (alphanumeric) | 0 (unknown) |
| International number, e.g. 91XXXXXXXXXX | 1 (international) | 1 (ISDN / E.164) |
| National number | 2 (national) | 1 (ISDN / E.164) |
| Let the SMSC decide | 0 (unknown) | 0 (unknown) |
Use the values confirmed during onboarding; the table shows the protocol conventions only.
Encoding and Unicode
| data_coding | Encoding | Characters in one SMS | Per segment when concatenated |
|---|---|---|---|
| 0 | SMSC default alphabet (usually GSM 7-bit) | 160 | 153 |
| 3 | Latin-1 (ISO-8859-1) | 140 | 134 |
| 8 | UCS-2 (Unicode, including Indian scripts) | 70 | 67 |
One character outside the GSM alphabet, such as a curly quote or an emoji, forces the whole message into UCS-2 and can more than double the segment count. Normalise punctuation where it matters, and make sure the text you submit matches your approved DLT template.
Multipart SMS considerations
SMPP offers three ways to send long messages: a User Data Header in each segment with the UDHI flag (esm_class 0x40), the SAR optional parameters (sar_msg_ref_num, sar_total_segments, sar_segment_seqnum), or a single message_payload parameter that the SMSC splits. Which methods are accepted for your account must be confirmed.
// Splitting a long message into UDH-concatenated segments (8-bit reference).
// GSM 7-bit: 153 characters per segment; UCS-2: 67. Characters from the GSM extension
// table count twice, so measure carefully. Confirm multipart support with your provider.
function segments(text) {
const ucs2 = /[^\x00-\x7F]/.test(text);
const size = ucs2 ? 67 : 153;
const parts = [];
for (let i = 0; i < text.length; i += size) parts.push(text.slice(i, i + size));
return parts;
}
function submitLong(session, base, text) {
const parts = segments(text);
const ref = Math.floor(Math.random() * 256);
parts.forEach((part, i) => {
session.submit_sm({
...base,
esm_class: 0x40, // UDHI: the body starts with a User Data Header
short_message: { udh: Buffer.from([0x05, 0x00, 0x03, ref, parts.length, i + 1]), message: part },
});
});
}Each segment is billed and receipted individually, and a message is only fully delivered when every segment is.
enquire_link keepalive
Idle TCP connections can be silently dropped by firewalls and NAT devices. Send enquire_link periodically (every 30 seconds is common) and treat a missing enquire_link_resp within a timeout (for example 10 seconds) as a dead link: close the session and reconnect. Always answer enquire_link from the SMSC as well. The correct interval for your account may be specified during onboarding.
Session recovery and reconnection
- Reconnect automatically after a close, error or keepalive timeout, using exponential backoff with jitter (for example 1, 2, 4… seconds, capped at one minute).
- Re-bind after reconnecting; sequence numbers restart on the new connection.
- Requests in flight when the link dropped have an unknown outcome. Reconcile them rather than resubmitting.
- Stop retrying on authentication failures and alert a person: repeated failed binds can look like an attack.
- Send
unbindand wait forunbind_respbefore closing during planned shutdowns.
Throughput and throttling
TXTPro provides variable SMPP throughput configurations based on customer requirements and applicable service plans. Contact our team to discuss your expected sending volume and TPS needs.
Pace submissions in your client so they stay below the configured rate, using a fixed interval or a token bucket shared across all transmitting sessions. If the SMSC rejects a submission for exceeding the rate (SMPP v3.4 defines ESME_RTHROTTLED, 0x58, and ESME_RMSGQFUL, 0x14, for a full queue), pause, then retry the same message first. How throttling is signalled for your account is confirmed during onboarding.
Throughput governs how fast messages are accepted, not how fast they are delivered: final delivery depends on operators and handsets.
Error and timeout handling
| Status | Name | Typical handling |
|---|---|---|
| 0x00000000 | ESME_ROK | Success |
| 0x00000005 | ESME_RALYBND | Already bound: check for duplicate sessions |
| 0x00000008 | ESME_RSYSERR | System error: retry later with backoff |
| 0x0000000B | ESME_RINVDSTADR | Invalid destination: fix the number, do not retry |
| 0x0000000D | ESME_RBINDFAIL | Bind failed: check credentials and IP whitelisting |
| 0x0000000E | ESME_RINVPASWD | Invalid password: stop and alert |
| 0x00000014 | ESME_RMSGQFUL | Queue full: back off and retry |
| 0x00000058 | ESME_RTHROTTLED | Throttled: slow down and retry |
Set a response timeout on requests (30 seconds is a common starting point) so that missing responses surface as errors. Classify every failure as permanent (fix the message), transient (retry with backoff) or unknown (reconcile). Providers may also use vendor-specific codes, which are listed in your onboarding documentation where applicable.
Security recommendations
- Keep the system ID and password in environment variables or a secrets manager; never commit them or put them in client-side code.
- Connect only from the whitelisted servers, and restrict outbound access on those servers to the endpoints you need.
- Treat connection details as confidential; share them internally only with people who operate the integration.
- Do not log passwords, full message text or OTPs. Log message IDs, statuses and masked numbers.
- Encryption in transit is not described here as a TXTPro capability. Ask during onboarding what transport protection is available for your account.
- Rotate credentials if they may have been exposed, and remove IP addresses you no longer use.
Troubleshooting
| Symptom | Likely cause | What to check |
|---|---|---|
| Connection refused or times out | Source IP not whitelisted, wrong host or port, firewall | Your egress IP, the onboarding details, outbound firewall rules |
| Bind rejected | Wrong system ID or password, unsupported bind type, wrong interface_version | Credentials, bind type and interface_version 0x34 |
| Session drops every few minutes | No keepalive, so an idle connection is cut by NAT | enquire_link interval and responses |
| Submissions rejected in bursts | Rate above configured TPS | Client pacing and throttling handling |
| No delivery receipts | registered_delivery not set, TX-only bind, receipts not acknowledged | Receipt requests, an active TRX or RX session, deliver_sm_resp |
| Receipts not matched to messages | Different message ID format in the receipt | Compare a real receipt with the submit_sm_resp message_id |
| Garbled characters | Wrong data_coding for the text | UCS-2 for Unicode text, GSM for plain English |
What to verify before using these examples with a TXTPro account
- Host, port, system ID, password and
system_type, from your onboarding details. - Bind type (TRX, or separate TX and RX) and any limit on concurrent sessions.
- Configured TPS and how throttling is signalled.
- TON/NPI values, header format and how DLT identifiers are passed.
- Delivery receipt format, message ID format and supported multipart methods.
- Keepalive interval, timeouts and any transport security options.
Compare the options in SMPP vs HTTP SMS API, or request an SMPP account to receive your connection details.
Frequently asked questions
Which SMPP version should my client use with TXTPro?
SMPP v3.4. Set interface_version to 0x34 in your bind request; some libraries default to v5.0 (0x50).
Should I use a TRX bind or separate TX and RX binds?
Both are supported. TRX is simpler to operate with a single session; separate TX and RX suits platforms that scale submission and receipt processing independently.
Why am I not receiving delivery receipts over SMPP?
Check that registered_delivery is set on each submit_sm, that a TRX or RX session is bound, and that every deliver_sm is acknowledged. Receipt availability also depends on routing and account configuration.
Can I resend a message if submit_sm times out?
Not blindly. A timeout means the outcome is unknown and the message may already have been accepted. Reconcile it using receipts or reports before resubmitting.
Does IP whitelisting encrypt my SMPP traffic?
No. IP whitelisting restricts which addresses may connect; it does not encrypt data in transit.
Sources and further reading
- SMPP Developers Forum — Short Message Peer to Peer Protocol Specification v3.4, Issue 1.2
- IANA — Service Name and Transport Protocol Port Number Registry (smpp)
- @semyonf/smpp — SMPP client and server library for Node.js (GitHub)
- 3GPP TS 23.038 — Alphabets and language-specific information (GSM-7 / UCS-2)
Editorial note: This article is written by the TXTPro editorial team (KSVL Solutions) for general information. Regulations and platform policies change; check the linked official sources and seek professional advice for your situation. See our editorial standards.
