How to Connect a Star Micronics Printer to Your Own POS App

You can prompt an AI builder to generate a sharp checkout screen in twenty minutes, complete with modifier grids, tax calculations, and a simulated receipt modal. Then a café owner hands you a Star TSP143IIIU or an mC-Print3, asks where the paper comes out, and your weekend project hits a brick wall. Turning pixels on a screen into physical ink on thermal paper means dealing with a twenty-year history of hardware protocols, operating system sandboxes, and manufacturer review queues.

Star Micronics is a staple on retail and hospitality counters because their printers survive kitchen grease, dropped cash drawers, and busy Friday night rushes. Connecting to them from your own software, however, means choosing the right Star Micronics SDK before you write a single line of print logic. Pick the wrong library for your specific model, or misunderstand how Apple treats Bluetooth accessories, and you'll spend weeks debugging silent failures.

If you're mapping out your entire counter setup beyond just the receipt printer, start with our guide to POS Hardware for Custom Apps: Printers, Drawers, Scanners, Displays. If you already have a Star printer sitting on your desk and need it talking to your code today, here is the engineering path.

Which Star Micronics SDK Should You Use: StarXpand or Legacy StarIO?

TL;DR: Use the modern StarXpand SDK for newer mC-Print, mPOP, and TSP100IV models, and only fall back to the legacy StarIO SDK if you have to support older hardware like the TSP100III or TSP650II.

Modern front-loading cube printers use the newer StarXpand SDK, while classic raster printers rely on the legacy StarPRNT and StarIO libraries.

The Star Micronics SDK is a collection of native and cross-platform software libraries that translate application receipt layouts into raw byte streams (like StarPRNT or Star Line Mode) that Star thermal printers and attached cash drawers execute. Right now, Star splits its developer tooling into two distinct generations.

StarXpand SDK (The Modern Standard)

StarXpand is Star's current, actively developed library. It ships natively for iOS (Swift/Objective-C) and Android (Kotlin/Java), alongside official wrappers for React Native, Flutter, and .NET MAUI.

Instead of forcing you to manually calculate byte arrays or manage separate command sets for different printer families, StarXpand uses a unified builder pattern (StarXpandCommandBuilder). You construct a document in code by adding text, barcodes, logos, and a cash drawer kick, and the SDK compiles the exact commands your specific printer needs.

Hardware support is the main limitation. StarXpand supports modern printers using StarPRNT command emulation: the mC-Print2, mC-Print3, mPOP, TSP100IV, and portable SM-L series. It does not support the ubiquitous older TSP100III series.

StarIO / StarPRNT SDK (The Legacy Workhorse)

Walk into an independent restaurant and there's a good chance you'll find a Star TSP143III (LAN, USB, or Bluetooth) sitting under the counter. Because the TSP100III series is a raster-only printer, printing graphic images rather than interpreting character strings onboard, it is excluded from StarXpand.

If a merchant requires you to use their existing TSP143III, TSP650II, or SP700 impact kitchen printer, you have to integrate the older StarPRNT SDK (StarIO and StarIO_Extension). Plenty of production POS apps still run on it reliably, though the API surface is clunky compared to StarXpand and cross-platform wrapper maintenance moves noticeably slower.

Bluetooth, BLE, LAN, and USB: What Each Interface Needs

TL;DR: Network (LAN) and Bluetooth LE printers let you code and ship immediately, while Bluetooth Classic printers on iOS force you through Apple's MFi hardware certification process.

Before writing discovery code, inspect the printer's interface board: LAN and BLE allow immediate deployment, while iOS Bluetooth Classic and USB require Apple MFi approval.

Before writing discovery logic, look at the back of the printer. Star sells identical printer shells with modular or fixed interface boards, and each connection type imposes very different rules on your app architecture.

• LAN (Ethernet) and Wi-Fi: The cleanest path for a multi-station shop. Your app discovers the printer over the local network via UDP broadcast (typically port 22222) and sends print jobs over TCP port 9100. No operating system hardware locks apply, and multiple iPads can share one kitchen printer, provided your SDK code properly opens and closes the socket connection around every print job so one tablet doesn't lock out the others.

• Bluetooth Low Energy (BLE): Supported on models like the SM-L200 and mC-Print3 (depending on the SKU). On iOS, BLE uses Apple's CoreBluetooth framework, so you don't need special Apple hardware certification to ship a BLE printer integration to the App Store. Bandwidth is the trade-off: pushing a dense bitmap logo over BLE takes noticeably longer than over LAN or Classic Bluetooth.

• Bluetooth Classic (MFi): Common on the TSP143IIIBI, TSP654IIBI, and mPOP. On Android, this is standard RFCOMM SPP (Serial Port Profile). On an iPad or iPhone, it uses Apple's ExternalAccessory framework. Your code will compile and run on a test device, and then Apple App Review will flatly reject your binary unless the printer manufacturer has whitelisted your exact bundle ID under Apple's MFi program.

• USB (Lightning / USB-C): Models like the TSP143IIIU and mC-Print3 let you plug an iPad directly into the printer, passing both data and power over a single cable so the tablet stays charged all day. On iOS, wired USB communication to a Star printer also routes through the ExternalAccessory framework, carrying the exact same MFi approval requirement as Bluetooth Classic.

Completing Star's MFi App Registration Form

If your iOS app needs to talk to a Bluetooth Classic or USB Star printer, you can't bypass Apple's MFi (Made for iPhone/iPad) gatekeeping. Because the printer is the certified hardware accessory, Star Micronics holds the MFi license and must register your software with Apple on your behalf.

For the architectural backstory on why Apple enforces this across all major hardware brands, read our breakdown on Do You Need MFi Approval to Print Receipts from an iPad App?. When you're ready to submit a Star printer iOS app, follow these five steps:

1. Configure your `Info.plist`: Before submitting anything, add the UISupportedExternalAccessoryProtocols key to your Xcode project's Info.plist. For virtually all Star MFi printers, the required protocol string is jp.star-m.starpro. You must also declare NSBluetoothAlwaysUsageDescription so iOS prompts the cashier for Bluetooth permission.

2. Build a working release candidate: Star and Apple don't pre-approve empty app shells. Your integration with the Star Micronics SDK must be complete, functional, and ready for submission.

3. Submit Star's MFi Application Registration Form: Go to the Star Micronics developer portal and fill out their MFi whitelist request. Provide your company details, App Store Connect App Name, exact Bundle ID (case-sensitive), version number, and the exact check-box list of Star printer models you intend to support.

4. Wait for the PPID: Star verifies your submission and forwards the metadata to Apple's MFi certification portal. Once Apple processes the link between Star's hardware and your Bundle ID (which typically takes several business days), Star emails you a Product Plan ID (PPID).

5. Paste the PPID into App Review Notes: When you click "Submit for Review" in App Store Connect, paste the PPID string directly into the Notes for Reviewer field. Without that number in the notes, the automated and manual checks for jp.star-m.starpro will trigger a rejection under Guideline 2.5.14.

This approval is strictly per-Bundle-ID and per-model-list. If you build white-label POS apps for five different restaurant clients under five separate Bundle IDs, you're filing that form five times. And if a client buys a new Star model next year that wasn't on your original form, you have to amend your registration before pushing an update.

Can You Print to a Star Printer from a Browser Using Star WebPRNT?

Most developers using general-purpose AI app builders (like Lovable, Bolt, or v0) don't build native Swift or Kotlin apps at all. They end up with a React web application running inside a browser tab.

If you run that web app on an iPad in Safari, you can't use the native StarXpand SDK, nor can you use the Web Bluetooth API because Apple refuses to implement Web Bluetooth in WebKit over fingerprinting concerns. Your browser tab is completely deaf to USB and Bluetooth hardware.

Star's answer for browser-based POS apps is Star WebPRNT. It is an HTTP-based printing protocol built directly into the firmware of specific network-enabled Star printers, including the mC-Print2, mC-Print3, TSP100IV, and older printers fitted with an IFBD-HI01X or HI02X intelligent network interface card.

Instead of opening a raw TCP socket (which browsers block), your JavaScript frontend uses Star's StarWebPrintBuilder JS library to construct an XML payload containing the receipt elements. You send that XML via a standard fetch() or XMLHttpRequest POST directly to the printer's local IP address (for example, https://192.168.1.150/StarWebPRNT/SendMessage). The printer's onboard web server parses the XML, fires the cash drawer, prints the receipt, and returns a JSON/XML status response letting your browser know if the paper cover is open.

The HTTPS Mixed-Content Trap

WebPRNT sounds effortless until you deploy your web app to a production https:// domain. Modern browsers enforce strict Mixed Content rules: a secure https:// web page is blocked from making an insecure http:// POST request to a local IP address like 192.168.1.150.

To make Star WebPRNT work in production without forcing merchants to disable security flags in Chrome or Safari, you have to generate a self-signed SSL certificate on the printer's web configuration page, download it to every iPad or computer in the shop, install it as a trusted root certificate in the OS settings, and lock the printer to a static IP via DHCP reservation. Walking a non-technical café owner through installing root certificates on an iPad over the phone is nobody's idea of a good Tuesday.

Common Errors That Stall Star SDK Integrations

Even when you pick the right SDK and clear MFi, three hardware realities routinely break custom POS builds during the first week of live service:

• Missing Local Network Permissions (iOS 14+): If StarDeviceDiscoveryManager returns zero LAN printers even though the printer has a solid blue network light, check your iOS permissions. Starting in iOS 14, apps need explicit user consent (NSLocalNetworkUsageDescription) to send UDP discovery broadcasts on the local subnet. If the cashier taps "Don't Allow" on first launch, your app is blinded to LAN hardware until they dig into iOS Settings.

• Bluetooth Auto-Connect Wars: Star Bluetooth printers like the TSP143IIIBI have an "Auto Connection" feature (toggled via a physical switch or the Star Setting Utility app). When enabled, the printer aggressively reconnects to the last iPad it talked to. If a shop has two iPads on the counter and wants to share one Bluetooth printer, Auto Connection must be turned off. Otherwise, Tablet A hijacks the Bluetooth channel permanently and Tablet B throws timeout errors.

• Raster vs. Command Emulation Mismatches: If a printer spits out six feet of blank paper or gibberish characters, your SDK command emulation doesn't match the printer's firmware mode. Newer printers handle StarPRNT natively, while older models like the TSP650II can be switched between Star Line Mode and ESC/POS via physical DIP switches on the bottom of the unit. Your SDK initialization has to match the physical switch state.

Or Skip the SDK and Let Final Station Handle the Star Printer

Building a custom checkout flow shouldn't mean spending weeks reading thermal printer byte tables, debugging UDP sockets, and waiting on PPID emails from Apple.

Running your custom checkout flow on a native station app lets you discover and route print jobs to LAN, USB, and Bluetooth printers without managing SDK code.

We built Final POS so makers and merchants can create the exact checkout workflow their business needs without hitting the hardware wall. In Final Build, you describe your store (a multi-course restaurant flow, a rapid retail barcode counter, or a custom service intake) and Build generates a working POS wired to real commerce rails: catalog, tax, inventory, and Adyen-powered Final Pay.

When it's time to print, you don't touch an SDK. You deploy your flow via Final Run to Final Station, our native app running on iOS, Android, macOS, and Windows (see how a Native Station differs from a browser-based Virtual Station). Because Final Station is already a native, hardware-integrated application, all the native bridge code and printer communication protocols are built in.

Once you set up a Native Station, connecting a printer happens right on the counter (full steps are in our guide on How to connect a Printer):

1. Open Station Settings → Printer inside the Final POS app on your Native Station.

2. Tap Discover Printers. The Station scans for nearby Bluetooth, USB, LAN, and AirPrint printers.

3. Tap your printer to add it to your active list, or tap Add Manually and enter its IP address if it sits across a segmented kitchen network.

From there, you can choose your paper size, set up multi-printer routing on a Station so bar tickets go to the bar and food goes to the line, and trigger the connected cash drawer automatically on every sale. You can also pair your existing counters with merchant-owned hardware like our 80 mm Final Print cloud printer (USB + LAN, 250 mm/s) or Final Flex self-order kiosks. You get a custom-built POS in minutes, and when the cashier taps print, the receipt actually comes out.

(Managing stores outside North America? We also publish our custom POS hardware integration guides in [Dutch](https://finalpos.com/nl/blog/pos-hardware-voor-aangepaste-apps-printers-lades-scanners), [Danish](https://finalpos.com/da/blog/pos-hardware-til-tilpassede-apps-printere-skuffer-scannere), and [Indonesian](https://finalpos.com/id/blog/perangkat-keras-pos-untuk-aplikasi-kustom-printer-laci-kasir-pemindai).)