Python application
A web request, task, data event or monitoring rule decides to communicate.
← All integrations
Connect Python
Official Python package · PyPI
PYTHON SMS & WHATSAPP SDK
Connect Python
to your real mobile.
Send SMS from your own connected phone number.Send WhatsApp and retrieve received SMS.Use it in Django, FastAPI, Flask, workers, data pipelines and automation scripts.
One pip commandInstall from the official PyPI packageTwo-way SMSSend and retrieve received messagesPython 3.6+Small requests-based client
$
pip install smsmobileapiinstalledimport os
from smsmobileapi import SMSSender
sms = SMSSender(
api_key=os.environ["SMSMOBILEAPI_KEY"]
)
response = sms.send_message(
to="+32470000000",
message="Your appointment is confirmed."
)
print(response)PYTHONBusiness event
→SMSMOBILEAPIAuthenticated route
→YOUR PHONESMS sent
PYTHON LOGIC. REAL MOBILE COMMUNICATION.
Your code controls the event.
Your phone remains the communication endpoint.
The Python package provides a focused client around SMSMobileAPI. It keeps application logic in Python while the connected mobile gives SMS workflows a real SIM, an existing phone number and normal reply behavior.
SMSMobileAPI
The platform authenticates, routes and records the requested operation.
Connected mobile
Your phone and SIM send SMS with the number your contacts already recognize.
Python response
Your application receives structured data it can log, inspect and use in the next step.
QUICK START
Install, connect and run a controlled SMS test.
Begin with a mobile and recipient you control. Load the API key from protected server configuration and inspect the returned object before connecting the code to a production trigger.
- 1Connect your phoneInstall SMSMobileAPI and verify that the mobile appears online.
- 2Install the packageUse pip inside your project’s virtual environment.
- 3Load the secretRead the API key from an environment variable or secret manager.
- 4Send and inspectCheck the returned data and confirm the activity in the dashboard.
$ python -m pip install smsmobileapisend_sms.py
import os
from smsmobileapi import SMSSender
sms = SMSSender(
api_key=os.environ["SMSMOBILEAPI_KEY"]
)
response = sms.send_message(
to="+32470000000",
message="Hello from Python!"
)
print(response)THREE FOCUSED OPERATIONS
Send SMS, send WhatsApp and retrieve received SMS.
The package intentionally stays small. Your Python application owns the business logic while the client handles the corresponding SMSMobileAPI request and returns the decoded response.
Use your connected phone number
The default parameters enable SMS. The selected connected mobile must be online and correctly configured.
response = sms.send_message(
to="+32470000000",
message="Order ready"
)Switch the channel explicitly
Enable WhatsApp and disable SMS. Link WhatsApp in the dashboard before calling the method.
response = sms.send_message(
to="32470000000",
message="Order ready",
sendwa=1, sendsms=0
)Bring mobile replies into Python
Retrieve received SMS and pass the returned data into your CRM, support or automation logic.
received = sms.get_received_messages()
print(received)FIT THE PACKAGE INTO YOUR PYTHON STACK
Use mobile communication where your application already makes decisions.
Keep the client in a service or worker layer. This separates channel access from routes, views, models and data-processing code.
DJ
Django
Trigger customer communication from services, management commands, signals or background workers.
Services · Commands · CeleryFA
FastAPI
Add controlled messaging behind authenticated endpoints and move longer work into a background task or worker.
Routes · Dependencies · TasksFL
Flask
Keep the SMSMobileAPI client in an application service and call it from validated business workflows.
Blueprints · Services · RQPY
Scripts & data jobs
Use Python for monitoring, scheduled reminders, ETL alerts and internal operational tools.
CRON · Pipelines · MonitoringTURN REPLIES INTO BUSINESS EVENTS
Received SMS become data your Python workflow can use.
Retrieve messages from the mobile connected to SMSMobileAPI, then apply your own contact matching, filtering, storage and escalation logic. The SDK returns the API response; your application decides what happens next.
- Attach a reply to a CRM contact
- Create or update a support ticket
- Trigger a human follow-up
- Feed an internal analysis pipeline
NEW SMS
+32 470 00 00 00“Yes, tomorrow at 10 works for me.”
Python workflow
PUBLISHED ON PYPI
A small, inspectable package built for standard Python projects.
Install it in a virtual environment, pin the version through your dependency workflow and review the public source before deployment. The package uses the familiar requests library and returns decoded JSON data.
- Packagesmsmobileapi
- Clientsmsmobileapi.SMSSender
- RuntimePython 3.6 or newer
- HTTP dependencyrequests
- LicenseMIT
PRODUCTION CHECKLIST
Keep automation secure, observable and predictable.
The package makes the request simple. Your application still needs to protect secrets, validate data, handle API errors and prevent duplicate sends.
- 01Protect the API keyLoad it from environment configuration or a secret manager, never from committed source.
- 02Validate and normalize numbersApply the correct international format for the channel before calling the SDK.
- 03Inspect returned dataThe client may return an error object; branch on the response instead of assuming success.
- 04Use timeouts at the workflow levelKeep web requests responsive by moving communication work into an appropriate worker when needed.
- 05Prevent duplicate sendsUse an idempotent business event or your own processed-state marker around retries.
- 06Monitor phone connectivityNative SMS operations depend on the connected mobile being online and ready.
WHAT PYTHON TEAMS CAN BUILD
Communication connected to data, automation and business logic.
CRM automation
Send contextual messages and attach received replies to the correct contact workflow.
Data pipeline alerts
Notify a real phone when imports, processing jobs or quality checks require attention.
Scheduled reminders
Run appointment, payment and operational reminders from a worker or scheduled task.
Monitoring escalation
Turn application or infrastructure events into SMS messages sent from a known mobile number.
PYTHON SDK FAQ
Clear answers before you add the package.
The Python module is a focused client for messaging. The mobile connection, dashboard visibility and broader platform APIs remain part of SMSMobileAPI.
Is the module officially available on PyPI?
Yes. Install the smsmobileapi package with pip. Its published metadata requires Python 3.6 or newer and uses the requests dependency.
Do SMS really leave from my own mobile?
Yes. SMS requests are routed through the mobile connected to your SMSMobileAPI account, using its SIM and existing phone number.
Can I retrieve received SMS in Python?
Yes. Call get_received_messages() on the initialized SMSSender instance, then process the returned data according to your application rules.
How do I send WhatsApp instead of SMS?
Connect WhatsApp in the dashboard, then call send_message() with sendwa=1 and sendsms=0. WhatsApp recipients use the country code without + or 00.
Can I use the package with Django, FastAPI or Flask?
Yes. Keep the client in server-side service code and call it from validated application workflows. Use a worker for operations that should not block a web request.
Does the package cover call, notification and every platform API?
No. The current package focuses on sending SMS and WhatsApp and retrieving received SMS. Use the REST API documentation for call activity, notifications and other specialized operations.
PYTHON READY. MOBILE CONNECTED.
Run your first real mobile workflow.
Install the package, test with a controlled number and connect the verified operation to the business event that matters.
