MicroSIP primarily interacts with external systems through command-line arguments and event-driven execution defined in the microsip.ini configuration file.
Command Line Control: You can launch specific actions or specify configuration files via the command line (e.g., MicroSIP.exe /i:custom.ini).
Event-Driven Commands: The MicroSIP online help details several settings (often not visible in the UI) that trigger external scripts or programs when call events occur:
cmdCallStart: Runs a command when a connection is established. cmdCallEnd: Runs a command when a call finishes. cmdIncomingCall: Triggers a command upon receiving a call.
cmdCallAnswer: Executes when a user answers an incoming call.
Note: In each case, the Caller ID is passed as a parameter to the external command. Third-Party and Custom API Projects
Because the native API is limited to local command execution, developers have created wrappers to expose more standard API endpoints:
Python MicroSIP-API: A project found on GitHub (dtremp007) provides an endpoint server for MicroSIP. It allows direct access to the MicroSIP database (FirebirdSQL) and uses uvicorn to host an API service for fetching article/SKU data.
PyPI Library: A microsip-api package exists on the Python Package Index, though it is largely a source distribution for specific integration needs. Core Architecture (PJSIP)
For deep integration or creating a custom build, MicroSIP is open-source and built on the PJSIP stack.
Source Code: The full source is available under the GPL v2 license on the official site or various GitHub mirrors.
Customization: Organizations can request a Custom Build from the developers for specific branding or feature requirements. MicroSIP source code
MicroSIP does not provide a formal REST or web API. Instead, it offers a robust Command Line Interface (CLI) external event triggers
that allow other applications to control the softphone or react to incoming calls. 🔌 Controlling MicroSIP (Outbound) You can control an active MicroSIP instance by running microsip.exe microsip api documentation
with specific command-line arguments. If the application is already running, it will process the command without opening a new window. Make a Call: microsip.exe sip:number@domain microsip.exe number Hang Up Call: microsip.exe /hangup Answer Call: microsip.exe /answer Minimize to Tray: microsip.exe /hide Restore Window: microsip.exe /show Exit Application: microsip.exe /exit đź”” Handling Events (Inbound)
MicroSIP can trigger external scripts or applications based on call status. This is configured in App events Incoming Call: You can specify a command to run when a call arrives. Placeholders: %callerid% to pass the caller's number to your custom script. C:\Scripts\log_call.bat %callerid% Call End/Answer:
Similar triggers exist for when a call is answered or terminated. Spiceworks Community 🛠️ Developer Resources Since MicroSIP is based on the PJSIP stack
, developers looking for deep integration often look at the underlying library documentation. Source Code: Available on the MicroSIP Source Page for custom builds. PJSIP Documentation:
Essential for understanding how the core SIP signaling works. Python Wrapper: A community-maintained microsip-api
exists on PyPI, though it is often used for interacting with MicroSIP's local database or configuration files rather than live call control. đź’ˇ Integration Examples Click-to-Call: Many CRMs use the
protocol handlers. You can register MicroSIP as the default handler for these links in Windows Settings. Database Access: MicroSIP stores contacts and call logs in a FirebirdSQL database ( Contacts.db or similar), which can be read by external reporting tools. If you'd like, I can help you with: batch script to handle incoming %callerid% Setting up URL protocol handling for click-to-call. Locating specific PJSIP library functions for a custom build. MicroSIP online help
MicroSIP itself is a lightweight open-source SIP softphone. Its "API" is primarily exposed via command-line arguments and Windows messages (WM_COPYDATA) , allowing external apps to control it.
Micro
MicroSIP is primarily an open-source softphone for Windows, and while it does not have a traditional REST API, it offers integration capabilities through a Command Line Interface (CLI) and INI configuration files. Documentation Review: Strengths and Limitations 1. Integration Depth (CLI and Automation)
Strengths: The MicroSIP online help provides a concise list of command-line arguments and configuration triggers. You can automate actions like starting a call upon connection or running commands when a call ends using parameters like cmdCallStart, cmdCallEnd, and cmdIncomingCall.
Weaknesses: The documentation is functional but sparse. It is better suited for sysadmins or developers looking for simple triggers rather than complex application integrations. 2. Configuration and Customization
Strengths: The use of an .ini file for settings makes it highly portable and easy to manage programmatically. Advanced users can even spoof the "User-Agent" string or adjust transport settings directly in the file. If MicroSIP is already running
Weaknesses: There is no official SDK or native library for embedding the softphone engine directly into other software beyond using its source code. 3. Community and Third-Party Resources
Strengths: Because it is open-source (GPL v2), you can access the C/C++ source code to understand its inner workings. There are also unofficial wrappers, such as a Python-based microsip-api on PyPI, though these are community-maintained and not part of the core project.
Weaknesses: Official support for integration issues is limited; most troubleshooting is handled through community forums or online help pages. Summary of Documentation Features Documented Capability Command Line Basic call control and application launching. Event Triggers
Execute scripts on call start, end, answer, or incoming status. Settings Full control via microsip.ini for portable deployments. Source Access Open source (C/C++) for deep custom modifications. MicroSIP online help
ini manually. * "cmdCallStart" - runs specified command when connection established. Caller ID passed as parameter. * "cmdCallEnd" MicroSIP online help
ini manually. * "cmdCallStart" - runs specified command when connection established. Caller ID passed as parameter. * "cmdCallEnd" Wish list - MicroSIP
MicroSIP does not currently have a comprehensive, natively published public API for general remote control. However, developers and advanced users typically interact with it through command line arguments, configuration file manipulation, or by leveraging the underlying PJSIP stack. 1. Command Line Interface (CLI)
MicroSIP supports basic command line switches for automation and deployment:
Configuration Loading: Use /i: to specify a custom configuration file.
Dialing: You can initiate calls by passing a SIP URI or number directly (e.g., microsip.exe ).
Automation Wishlist: Note that advanced CLI functions like "pick-up" or "explicit video start" are frequently requested community features but are not part of the standard stable release. 2. Configuration & Integration
For deeper integration, you can programmatically modify the application's behavior:
microsip.ini: Most settings, including account details, codecs, and behavior, are stored in this file. bidirectional control between processes.
Provisioning API: For organizations, MicroSIP offers a Custom Build service that supports a REST API for provisioning. Your server can return SIP credentials and settings in JSON format to the client.
Event Handling: While it lacks a "push" API, users often handle incoming calls by configuring "Auto Answer" or using third-party tools to monitor the application window for specific events. 3. PJSIP Library (For Developers)
Because MicroSIP is an open-source project based on the PJSIP library, developers looking for full programmatic control over SIP functions often use the PJSIP API directly rather than the MicroSIP GUI application. 4. Third-Party Wrappers dtremp007/Microsip-API - GitHub
PowerShell (Initiate a Call):
Start-Process "C:\Program Files\MicroSIP\MicroSIP.exe" -ArgumentList "sip:8005551234@sip.example.com"
Batch File (Graceful Shutdown):
"C:\Program Files\MicroSIP\MicroSIP.exe" exit
To get audio device IDs for SetDevice:
MicroSIP.exe --listdevices
Output:
Output devices:
0: Speakers (Realtek)
1: Headphones (USB Audio)
Input devices:
0: Microphone (Realtek)
1: Headset mic (USB)
Then send: [SetDevice(output,1)]
If you have multiple SIP accounts configured in MicroSIP.ini:
MicroSIP.exe account:2 # Switches to account number 2 (zero-indexed or 1-indexed based on version)
MicroSIP is a lightweight, open-source Session Initiation Protocol (SIP) softphone for Microsoft Windows, known for its minimal resource usage (under 5 MB memory footprint) and reliance on the Windows native API rather than .NET or Qt frameworks. Unlike many VoIP clients, MicroSIP does not expose a RESTful or WebSocket API. Instead, it provides two primary programmatic control mechanisms:
This paper analyzes the official API documentation (available via microsip.exe /? and the source code comments) to evaluate its capabilities, limitations, and practical applications.
| Command | Argument | Description | Example |
| :--- | :--- | :--- | :--- |
| (None) | number | Launches MicroSIP and immediately dials the number. | microsip.exe 1001 |
| call | number | Dials the number (same as default behavior). | microsip.exe call 1001 |
| chat | sip_address | Opens the chat window for a specific SIP address. | microsip.exe chat sip:user@domain.com |
Usage Notes: