How to Read and Edit Plist Files
Last updated:
To read and edit a plist file is to work with Apple's configuration format — the key-value files that quietly run macOS and iOS. Every app carries an Info.plist, every scheduled background job is a launchd plist, every provisioning profile and every .mobileconfig device profile is a plist underneath. The format itself is simple: dictionaries, arrays, strings, numbers, booleans, dates, and data, nested as deep as you like. The trouble starts because the same format ships in two costumes — human-readable XML, and a compact binary form that looks like garbage in a text editor — and because one wrong type can silently stop a job from ever running. You can paste any plist into the Plist Workbench and read, edit, convert, and validate it in your browser — nothing is uploaded — but this article teaches you to read the files yourself, so the tree is never a black box.
What a plist is — and the four costumes it wears
A property list, or plist, is Apple's way of storing structured configuration: a tree of dictionaries and arrays whose leaves are strings, integers, real numbers, booleans, dates, and binary data blobs. It is the same idea as a JSON object or a YAML file, but it predates both on Apple platforms and it is baked into the operating system — macOS and iOS read plists constantly, without ever asking you. If you have ever wondered where an app keeps its bundle ID, its version, or the permissions it requests, the answer is a plist, and it has been sitting in plain sight all along.
The same format shows up in four places that look unrelated until you know the trick. Inside every app bundle, Info.plist declares the app's identity: its bundle ID, version, supported document types, and the permissions it asks for. In ~/Library/LaunchAgents and /Library/LaunchDaemons, launchd job files describe background tasks — what to run, when, and under what conditions. A .mobileprovision provisioning profile is a plist (wrapped in a CMS signature) listing which devices and entitlements an app may use. And a .mobileconfig device profile is a plist describing Wi-Fi, VPN, certificates, and restrictions to install on a device. Same format, four costumes — learn to read one and you can read all four.
Binary vs XML: the bplist00 magic, and why hand-editing a binary plist corrupts it
A plist has two serialisations. The XML form starts with <?xml and <plist version="1.0">, and you can read it in any text editor: keys in <key> tags, values in <string>, <integer>, <true/>, <array>, and <dict>. The binary form is a compact encoding that starts with the eight magic bytes bplist00, followed by an object table, an offset table, and a trailer that records where everything lives. Binary plists are smaller and faster for the system to load, which is why most of the plists on a real Mac are binary — and why opening one in a text editor shows garbage.
How to tell which one you have: look at the first bytes. bplist00 means binary; <?xml or <plist means XML. And here is the rule that saves files: never edit the binary bytes by hand. A binary plist is a web of offsets — change one string to a longer one and every offset after it is wrong, the trailer no longer matches the table, and the file is corrupt even though the text you changed looks fine. The safe path is always the same: convert binary to XML, edit the XML, convert back to binary, and then re-parse the result to prove it is still valid. On a Mac that is plutil -convert xml1 and plutil -convert binary1; in the browser, the Plist Workbench does the same round trip for you.
Reading a launchd job by hand: Label, ProgramArguments, RunAtLoad, KeepAlive, StartCalendarInterval
A launchd job is a plist with a small vocabulary, and you can read one in under a minute once you know the keys. Label is the job's unique name, conventionally a reverse domain like com.example.backup — launchd uses it to identify the job, and two jobs with the same label collide. ProgramArguments is an array of strings: the program to run followed by its arguments, so ["/usr/local/bin/backup.sh"] runs that script with no arguments. RunAtLoad is a boolean: true means run the job as soon as it is loaded. KeepAlive, also a boolean, means restart it whenever it exits. Those four keys describe most jobs you will ever meet.
The scheduling key is StartCalendarInterval, a dictionary of calendar fields — Minute, Hour, Day, Weekday, Month — any of which you may omit, so {Hour: 3, Minute: 30} means every day at 03:30. Its simpler cousin StartInterval is a single integer: run every N seconds. The sample in the code block below is a complete, working job in this shape — Label, ProgramArguments, RunAtLoad, StartCalendarInterval — and it is worth reading line by line, because every launchd job you meet is a variation on it: the same keys, different values, and the occasional extra like WorkingDirectory or StandardOutPath for where output goes.
The keys that break things: type mistakes, wrong containers, out-of-range numbers
Most broken launchd jobs are not broken by typos — they are broken by types. launchd expects ProgramArguments to be an array of strings; hand it a single string instead and the job fails to load, with an error that says very little. KeepAlive, RunAtLoad, and Disabled must be booleans, not the strings "true" and "false" — a string that spells "true" is not true, and launchd will treat it as a type error. StartInterval must be a positive integer; a zero or a negative number is meaningless and rejected. These are the mistakes a text editor never catches, because the XML is perfectly well-formed — only the meaning is wrong.
The second family of breakage is numbers outside their range. In StartCalendarInterval, Minute must be 0–59, Hour 0–23, Weekday 0–7, Day 1–31, and Month 1–12 — an Hour of 25 does not mean "tomorrow at 1am", it means the job never runs, and launchd may not even tell you why. The third family is the pair that must not both appear: Program and ProgramArguments are two ways to say the same thing, and giving both is ambiguous — pick one, and prefer ProgramArguments, which is the form Apple documents. A validator that checks types, ranges, and these conflicts catches all three families before the job ever reaches launchd, which is exactly what the workbench's launchd checks do.
Editing safely: back up, convert, edit, convert back, verify
Safe plist editing is a five-step ritual, and the steps matter in this order. First, back up the original file — copy it somewhere before you touch it, because a launchd job or a device profile has no undo button. Second, if the file is binary, convert it to XML; never edit binary bytes directly, for the offset reasons above. Third, make the edit in the XML: change a value, rename a key, add an array item — and keep the types right, a string where a string belongs, an array where an array belongs. Fourth, convert back to binary if the original was binary, so the file goes back in the form the system expects.
Fifth, and most often skipped: verify by re-parsing. Run plutil -lint on the result, or paste it into the workbench and watch it parse clean — if the file re-parses and the values you intended are the values that came back, the edit worked. If it does not parse, you still have the backup from step one, and the file on disk was never touched by the editor in the first place: the workbench edits a copy in memory and only writes a file when you explicitly export one. That last property is the whole point of editing in the browser — the original stays intact until you decide the new version is good.
What the Plist Workbench does — and what it does not do
The workbench parses both forms of plist — binary bplist00 and XML — into a tree you can expand, search by path (like StartCalendarInterval.Hour), and edit in place: change a scalar, rename a key, add or delete keys and array items, and change a value's type where that is unambiguous. Every export — XML plist, binary plist, JSON, or a CSV of the flattened path table — reflects the edited model, not the original file. When the plist looks like a launchd job, it runs the semantic checks from the previous sections: Label present, exactly one of Program and ProgramArguments, calendar fields in range, booleans actually boolean. That is the whole job, and it all happens in your browser: the file never leaves your device.
What it does not do is just as important. It does not install anything — it will not load your job into launchd, install a .mobileconfig on a device, or provision an app; those are system actions, and a web page should not perform them. It does not validate code signatures or provisioning entitlements against Apple, so an edited .mobileprovision may parse perfectly and still be rejected by the system because its signature no longer matches — parsing is not trust. And it does not run anything from the plist: a launchd job that points at a script is data until launchd executes it, and the workbench treats it as data. For the Android equivalent — the manifest inside an APK — use the APK Analyzer; for launchd's Linux cousin, systemd units, use the systemd Unit Auditor.
Try it yourself: a launchd job you can read, convert, and verify
# A minimal launchd job, as XML — the form you can read and edit safely
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.example.backup</string>
<key>ProgramArguments</key>
<array>
<string>/usr/local/bin/backup.sh</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>StartCalendarInterval</key>
<dict>
<key>Hour</key>
<integer>3</integer>
<key>Minute</key>
<integer>30</integer>
</dict>
</dict>
</plist>
# Convert between the two forms on a Mac — never edit the binary bytes:
$ plutil -convert xml1 job.plist # binary -> readable XML
$ plutil -convert binary1 job.plist # XML -> compact binary, for shipping
$ plutil -lint job.plist # re-parse to verify it is still valid