Dylan Pak (@kidpakerot)

Approach

How Warmr works

Warmr is a Mac app that posts your content to TikTok and Instagram on a schedule, from iPhones you own.

50+iPhones
3,000+posts
2posting platforms, TikTok and Instagram
0jailbreaks

Scope

There are two ways to automate posting to TikTok. The same split applies to Instagram.

The first is to reverse-engineer the app and call its private API directly. It breaks the platform's terms, and it is an arms race: every constant copied out of the binary has a shelf life. Warmr does not do this.

The second is to instrument the phone. A physical iPhone, the production TikTok or Instagram build from the App Store, a real account, driven through the same XCTest input path Apple uses for UI testing. The client signs its own requests, so there is nothing to reverse and nothing that rots when the app updates. The cost is one device's worth of throughput per device, and every action has to be synthesized as a touch event and verified from a screenshot.

Warmr is the second kind. Posting on a schedule is the main job. The other mode is an activity routine: the account does not publish, it browses the feed, searches your keywords, and sometimes likes, follows, or saves, on a light schedule you set. A posting run takes the next file from a folder and walks the platform's publish flow.

We built it and run it. This page is the technical writeup, layer by layer, from Xcode code signing to the scheduler.

Emulation versus physical devices

The trade-off, stated plainly. Neither column is a strawman.

Signed-API emulationReal iPhone
Reads (profiles, videos, comments)High volume through the private APIOne feed at a time
Writes (post, like, follow, comment)Account-gated, mostly out of reachEvery action the app can do
MaintenanceRe-derive constants on every app changeRe-measure a few tap targets when the UI moves
Failure modeEmpty 200, no reason givenA screenshot of what went wrong
Cost per unitServers and bandwidthA used iPhone and a USB port

Warmr runs phones.

Official apps, no forged requests

Warmr runs the App Store builds of TikTok and Instagram. The apps sign their own requests and pick their own servers, so Warmr never forges, intercepts, or replays network traffic. What Warmr does is tap a UI that never idles, check every step from a screenshot, and keep a set of phones running.

Fleet requirements

Reduced to requirements, a fleet controller has to:

  1. Supervise one control agent per device and restart it on every failure mode: lock, memory pressure, USB brownout, xcodebuild timeout. Warmr calls that device a lane. One lane is one iPhone on USB. A thread runs on a lane, and an account is published from one lane at a time.
  2. Stream every screen to a browser over MJPEG and accept operator input when automation stalls.
  3. Persist "post this asset at 09:00 Tuesday" so it survives a reboot, a crash, and a redeploy.
  4. Synthesize input against a UI that never reaches XCTest quiescence.
  5. Resolve every tap target per device, per screen geometry, across app releases.
  6. Guarantee at-most-once delivery for anything that publishes.

Each has a specific answer below.

Fleet output

The fleet behind the numbers at the top.

MetricValue
Devices50+ iPhones
Posts published3,000+
Posting platformsTikTok and Instagram
Jailbreaks0
Forged requests0

Warmr does the posting. Which asset goes out is the operator's choice.

Device layer

Pairing, DDI mount, and code signing through Xcode

A jailbreak would give us root on the phone. We did not want root. We wanted the input path Apple ships for its own UI tests: WebDriverAgent, an XCTest bundle that runs on the device, talks to the XCTest daemon over XCTestDaemonsProxy, and exposes a WebDriver-style HTTP server for synthesized pointer events, screenshots, and an MJPEG frame stream.

That decision means Warmr never talks to the device at the USB level for control. It delegates the whole pair, trust, sign, and launch chain to Xcode, and inherits Xcode's rules:

  • Pairing and trust are the OS's job. The phone must be plugged in, have accepted "Trust This Computer", and on iOS 16+ have Developer Mode enabled. Warmr discovers a device over usbmuxd; it never initiates pairing.
  • Signing reads the login keychain. WebDriverAgent is signed with your own Apple team using automatic signing. The keychain is only unlocked in a graphical session, which is why the build step must run from Terminal.app and fails over bare SSH. Every operator hits this once.
  • A free Apple ID has a 100-UDID limit. Automatic signing embeds the connected UDIDs into the provisioning profile, so a new phone must be plugged in when the agent is built. At scale you count slots.
  • The Developer Disk Image must be mounted for the phone's exact iOS version before xcodebuild can launch anything. Pairing once with Xcode does it.

The registration wizard in the dashboard is a UI over exactly this chain. It probes each link (Xcode selected, device visible, signing identity present, disk image mounted, agent reachable, video streaming, touch working, TikTok or Instagram installed) and shows the specific fix before it writes the device to disk. Most support questions we got before the wizard existed were one of those checks failing silently.

WebDriverAgent supervision and USB port forwarding

WebDriverAgent dies. The phone locks, iOS reclaims memory, the USB hub browns out, xcodebuild times out. A multi-phone setup is defined by what happens next.

A dedicated process called wda-service owns every agent. It launches xcodebuild test-without-building per active device, forwards the agent's HTTP port and MJPEG port over USB to the host (8100, 8101, ... and 9100, 9101, ...), watches health, and relaunches on failure. It is controlled over a Unix socket and takes a directory lock so a second copy cannot start; the second one sees the first is healthy and exits.

Health is per device and has real states, not a boolean: ready, unlock-required, error, and so on. unlock-required matters because a locked phone is the most common reason a job stalls, and the fix is different from every other failure. Warmr's operator docs stack recovery in layers for the same reason: classify the error before you restart the app.

The dashboard's remote control goes straight to the agent, not through Appium. The device grid polls stills; the device page streams the MJPEG feed and aborts the upstream when your browser tab closes, so idle tabs do not saturate the hub.

Two source patches to WebDriverAgent

Stock WebDriverAgent could not do two things a multi-phone setup needs. Both fixes are small source patches applied at build time.

Import media into Photos. TikTok's composer, and Instagram's, pick from the camera roll, so a post job has to get a video onto the phone first. We added a /wda/import-media route that takes a file as base64 JSON, requests add-only Photos permission, writes the asset through PHPhotoLibrary, and returns the new asset count. That count is load-bearing later. The route caps files at 350 MB because base64 plus a JSON copy runs into Node's string limit before the phone runs out of room.

Press hardware buttons without a session. Unlocking a phone means pressing Home, typing a passcode on the keypad, and doing it before any Appium session exists. Stock WDA only exposes /wda/pressButton inside a session. We registered the same handler sessionless. The passcode keypad has its own coordinate layout so auto-unlock works on the lock screen, which has no accessibility tree worth querying.

Client instrumentation

XCTest quiescence and waitForIdleTimeout: 0

XCTest, and therefore Appium, wants an app to settle before it acts. It waits for the UI to become quiescent, then resolves an element, then taps it. TikTok's home feed is a video that never stops, with a live-updating overlay, and it is never quiescent. Instagram's feed has the same problem. The first version of the scroll loop would issue a swipe and hang until the proxy timed out.

Two settings fix it and both are in the capabilities we send:

'appium:waitForIdleTimeout': 0     // do not wait for quiescence, ever
coordinate taps and swipes only     // bypass element lookup on the feed

Every gesture in the scroll loop is a raw pointer action at a coordinate: pointer down, pause 100 ms, move over 450 ms, pointer up. No accessibility query on the feed, ever. Element queries are used only on screens that are static, like the "Use this sound" button on a music page.

Point-space coordinate profiles and per-device overrides

Once you stop querying elements, you need to know where things are. A coordinate profile is the full set of tap targets for one screen geometry: the five tab-bar buttons, the composer, the media picker grid, the caption field, the keyboard dismiss button, Post and Drafts, the like and save icons, and the swipe vector. All in points, not pixels, because the agent reports a point-sized screen and screenshots come back at device-pixel resolution. Every pixel measurement is divided by the scale factor before it becomes a tap.

The shipped profile is iphone8, 375 by 667 points. It also fits the iPhone SE 2 and 3 and the iPhone 7, which is why a set of used SE phones is the cheapest setup you can build. Any operator can re-point the fifteen single-tap targets per device from the dashboard by clicking on the live screen; the override is stored on that device and merged over the profile at runtime. The picker grid, the swipe vector, and the passcode keypad are not single points and stay profile-level.

Locating like and save by normalized cross-correlation

The like and save buttons are the two targets that move most often. They sit in a column on the right edge, and their vertical position shifts with caption length, with whether a sound row is present, and between app releases. A fixed coordinate was right most of the time and silently wrong the rest.

So the scroll job locates them at runtime. It takes a screenshot, reduces it to a max-channel intensity map, renders a heart and a bookmark template from SVG paths at the device's scale factor, mean-centres both, and runs normalized cross-correlation over a search strip: the right 90% to 96% of the width, between 25% and 76% of the height, stepping every three pixels. It keeps the top thirty candidates for each shape.

Then it applies the one fact that makes the detector reliable: the two icons are a pair. Bookmark sits below heart, within 24 points horizontally, separated by 14% to 25% of the screen height. It picks the pair whose weaker score is highest. If that score is under 0.18 it gives up and falls back to the profile coordinates, and says so in the log. No model, no training data, about 150 lines.

Pixel sampling and Tesseract OCR for UI state

Two other places where the UI tree is useless and pixels are not.

Checkboxes. TikTok's media picker has "Select multiple" and "Use layout" toggles that persist between picker sessions. A blind tap assuming they start off will turn an already-on "Select multiple" off and silently drop you into single-select. Before deciding to tap, the job samples a 20-pixel radius around the checkbox and counts pixels that are TikTok red (R over 200, G under 90, B under 110). More than 50 red pixels means checked. It taps only if the state is wrong, re-checks, and gives up after three tries.

Which account is signed in. A phone can hold several accounts and a job can name one. Confirming the switch means reading the handle on the profile page, and the handle is text. We run Tesseract on the screenshot, parse the TSV output, keep only word-level rows with confidence over 40, and match the handle exactly first, then by substring with a length-ratio guard so a stray misread glyph does not match everything. Every fuzzy match is logged with what OCR actually saw. Warmr fails the switch closed: a one-character difference is a different account.

The account switcher is where dynamic target location failed. A fresh launch pops a transient tooltip over the profile header, different text each time, and it swallows taps. We first located the switcher trigger dynamically by OCR. It was not reliable enough to keep. What held up under repeated real-device runs was a fixed, live-calibrated coordinate plus four retries with an OCR check for the word "Switch" after each. The error message when it fails includes every word OCR could see, which is what you need at 2am.

An idempotent post pipeline

The post job is the one where a retry can do damage. The flow is: unlock, import media to Photos, open the composer (or deep-link a sound and tap "Use this sound"), select media from the picker, Next, Next, caption, then Post or Drafts. A posting run in Warmr takes the next media file from the account folder, can add music and a caption, walks TikTok or Instagram's publish flow, waits for processing, marks the file used, and moves to the next account.

Captions come from one of four sources on the template: inline text, a TXT file, a JSON file, or a sidecar file next to the video.

Two details in the picker. Photos "Recents" is newest-first, so files are imported in reverse order and the asset count from the import route is used to compute the exact cell of each one. And the composer-to-picker stretch is the fragile part (flaky toggles, tooltips, timing), so it is retried up to three times with a full app relaunch between attempts.

Everything after the caption screen is never retried. A second Post tap after a first one that actually succeeded is a duplicate post, and a duplicate is worse than one clean failure that a human reads in the log. After Post the job deliberately holds the session open for 60 seconds, because the upload continues in the background and tearing down early can interrupt it. A post that only saved a draft is a failure, not a success.

Behavioural model

Stochastic interaction profiles

A scroll session has a duration and a personality. The personality is a small table of probabilities. These are the ones shipped.

SkimmerCasualEngaged
Watch per video1.5 to 4 s4 to 9 s8 to 18 s
Like chance8%18%35%
Save chance2%6%15%
Linger chance5%10%20%
Linger extra4 to 8 s8 to 15 s15 to 30 s

Each decision is an independent Bernoulli draw against the profile; watch and linger durations are uniform within their bounds and clamped to the session deadline. Likes are a double tap 130 ms apart, so UIKit's gesture recognizer classifies it as double-tap-to-like and not two taps. Every interaction has a 200 to 600 ms pause before it. None of this is a claim about what TikTok's or Instagram's ranking models do or do not detect. It is the smallest parameter set that made a session read as human to a person watching the live feed.

Warmr also inserts three explicit pauses around the work itself: between publications, between accounts, and between cycles. A real session does not post three videos in thirty seconds and then start the list over.

Cooperative cancellation over SIGTERM

Every wait in the loop races against a stop signal. Pressing Stop sends SIGTERM to the job; the current sleep is cut short, the loop exits, the Appium session is deleted, and the job reports reason=stopped with the counts it reached. Nothing waits out a 30-second linger to notice it was cancelled.

Durable scheduling

Versioned task envelopes on pg-boss

Everything durable is in PostgreSQL. Schedules, executions, attempts, logs, and uploaded assets are tables. The job queue is pg-boss, also in Postgres, with one queue per device so a stuck phone never blocks its neighbour.

Every schedule and every execution row carries a task envelope:

pluginId    "com.git-agni.tiktok"
taskType    "doomscroll" | "post"
taskVersion 1
payload     validated, version-specific JSON

The version is stored, not implied. If you ship version 2 of the post task and uninstall version 1, every old schedule fails loudly instead of quietly running the new contract. This sounds like ceremony until the day a payload field changes meaning.

The worker materializes due schedules every five seconds and picks up newly registered phones every thirty. A run has a window, thirty minutes by default; past it, an execution is abandoned as "window expired" rather than firing a 9am post at 4pm because the Mac was asleep. Each phone keeps one canonical schedule. When a warm-up and a post are both due, the earlier one runs. If they tie, the post wins, and the next-run preview uses that same choice.

Operations

launchd, file descriptors, and powered USB

The production shape is a Mac, a powered USB hub, one iPhone per port, and four launchd agents: Appium, wda-service, the worker, and the web dashboard. Three settings on the Mac make it hold:

  • Raise open-file limits. WebDriverAgent plus one MJPEG stream per phone is hungry.
  • Disable sleep, display sleep, and disk sleep. A sleeping Mac drops USB and takes every agent with it.
  • Use a hub with its own power. Phones charge from it; an unpowered hub browns out under load and the failure looks like random WDA crashes.

Loopback bind and the authentication gate

The dashboard binds to 127.0.0.1 by default. The server refuses any other bind address unless an authentication provider is configured, and it fails at startup rather than warning. A Warmr dashboard cannot end up on the open internet by accident.

Device passcodes live in a git-ignored devices.json with mode 0600, not in environment variables. Plugins are trusted code with the same access as the service account, so pin them exactly and review them like server code. Platform logins stay on the Mac. Cloud Drop only queues the file the Mac will pull.

What stays on the Mac

Accounts, the device list, and the content never leave the Mac that runs Warmr. Warmr is the Mac app you install.

Warmr

Warmr posts your content and keeps accounts active on TikTok and Instagram. It is the Mac app that runs on iPhones you own. Solo and Rack include a 7-day trial. Scale is $999/mo, three spots left. Scale guarantee terms.

See pricing

FAQ

Does it need a jailbreak? No. Stock iPhones, the App Store builds of TikTok and Instagram, signed with your own Apple team.

Can this conflict with a platform's terms? It can. Most platforms limit automated use of their apps, and that applies to schedulers and growth tools too. Use Warmr only on accounts you own, read each platform's terms, and you carry that risk. Warmr does not promise views, followers, or income.

Android? Not in this build. The architecture is device-agnostic above the agent layer, and an Android plugin would replace WebDriverAgent with UIAutomator2 behind the same task envelope. We have not built it.

Other apps? TikTok and Instagram are the posting platforms. X and LinkedIn can be kept active between posts you publish yourself. Warmr does not publish to them, and it does not publish YouTube Shorts. A plugin gets versioned tasks, the device, per-device data, uploaded assets, a workspace, cancellation, durable logs, and safe device primitives.

How many phones? The fleet behind the numbers above is 50+ iPhones. Each phone gets its own agent and ports. The limits are USB power and the open-file ceiling, not the scheduler. One Mac on the homepage drives 10 or more.

Where do I ask something? Email hi@warmr.so. Dylan Pak is @kidpakerot.

Pick a plan

Solo and Rack include a 7-day trial. Scale is $999/mo, 3 spots left.

See pricing Set up with Claude