Batch Export RAW Files in Capture One on a Rented Mac

Short answer: request a Figment M-series Mac (from $95/month, exact chip/RAM/disk confirmed in the quote), copy the Capture One session as a folder, build a TIFF delivery recipe and a JPEG proof recipe, and trigger them overnight with launchd and osascript. The studio Mac stays free for the next shoot. The $29 virtual Intel macOS VM runs on 2 vCPU/8 GiB RAM/80 GiB disk, uses a browser console for access, and has no GPU acceleration or audio — keep it for recipe tuning and small test batches, not for a 2,000-file CR3 run. Before you commit, confirm the Capture One version you intend to install supports the macOS image on the plan you request.

Sessions vs catalogs for a rental workflow

Capture One offers two library models. A catalog stores previews and metadata inside one database file, which travels poorly over the network. A session keeps Capture, Output, Selects and Trash as plain folders mapped to the shoot. For a rented Mac, sessions win:

• The session is a folder — rsync it, zip it, or push it through object storage.
• The rented Mac never needs your master catalog.
• Outputs land inside the same folder tree, so retrieval is a single download.
• When the job finishes, import the session into your archive catalog in one step.

Use catalogs for long-term archive, sessions for each shoot.

Moving the RAWs to the rented Mac

The $29 VM is reached through a browser console; inbound SSH is not available on that plan, so transfer files through the desktop session or an object-storage bucket pulled from the guest. For an i3 or M-series request, confirm the access and transfer path (SSH, SMB or screen share) in the quote before you plan the transfer.

Where SSH has been configured on your physical plan, a drop-safe push from the studio Mac looks like this. Quote paths with spaces and keep --checksum for retries:

rsync -avz --progress --partial --checksum \
  "$HOME/Pictures/Sessions/ClientName_2026-11-10/" \
  "user@rented-mac.example.com:Sessions/ClientName_2026-11-10/"

Verify with a count before kicking off the export — the numbers must match:

# Studio Mac
find "$HOME/Pictures/Sessions/ClientName_2026-11-10/Capture" -iname "*.CR3" | wc -l
# Rented Mac
find "$HOME/Sessions/ClientName_2026-11-10/Capture" -iname "*.CR3" | wc -l

Building export recipes and token names

Open the Export tool tab in Capture One and add recipes with the + button. One recipe produces one format, profile and destination; you can tick several recipes at once and Capture One queues them together.

Two recipes that fit most commercial deliveries:

1. Client_TIFF_300dpi — TIFF 16-bit, destination ICC (for example ISO Coated v2), 300 PPI, no resize. If the profile isn't listed, drop the .icc into ~/Library/ColorSync/Profiles/ and relaunch.
2. Client_JPEG_web — JPEG, sRGB, 90% quality, long edge 2048 px, for the proofing gallery.

Naming tokens live behind the {…} button next to the Name field. Common tokens used in commercial deliveries:

A readable delivery string: Job Name + Counter + Image Name → ClientName_0001_DSC_0042. Token wording and digit-width options vary between Capture One builds, so pick tokens from the {…} picker in your installed version before you trust the schedule. Put a sub-folder token in the Location tab's sub-folder field so each export lands in its own dated folder.

Scheduling the batch with launchd

launchd runs the job at 02:00 and you walk in to finished files. Capture One exposes an AppleScript interface, and osascript is the shell bridge. Before you rely on this, open Script Editor → File → Open Dictionary and pick Capture One on the rented Mac to confirm the exact export verb your installed build publishes — it has varied between versions.

#!/bin/bash
# ~/bin/co_batch_export.sh
set -euo pipefail

SESSION="$HOME/Sessions/ClientName_2026-11-10/ClientName_2026-11-10.cosessiondb"
LOG_DIR="$HOME/Logs"
LOG="$LOG_DIR/co_export_$(date +%Y%m%d_%H%M%S).log"
mkdir -p "$LOG_DIR"

# Replace the AppleScript export verb with the one listed in your Script
# Editor dictionary. The here-doc below is passed on stdin, with the session
# path appended as a positional argument.
/usr/bin/osascript - "$SESSION" >>"$LOG" 2>&1 <<'APPLESCRIPT'
on run argv
  set sessionPath to POSIX file (item 1 of argv)
  tell application "Capture One"
    activate
    open sessionPath
    delay 15
    -- Example only; confirm the verb your build publishes.
    process every variant of current document
  end tell
end run
APPLESCRIPT

echo "co_batch_export finished at $(date)" >>"$LOG"

Save the plist as ~/Library/LaunchAgents/com.studio.co_batch_export.plist:

<?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.studio.co_batch_export</string>
  <key>ProgramArguments</key>
  <array>
    <string>/bin/bash</string>
    <string>/Users/you/bin/co_batch_export.sh</string>
  </array>
  <key>StartCalendarInterval</key>
  <dict>
    <key>Hour</key>
    <integer>2</integer>
    <key>Minute</key>
    <integer>0</integer>
  </dict>
  <key>StandardOutPath</key>
  <string>/Users/you/Logs/co_launchd.log</string>
  <key>StandardErrorPath</key>
  <string>/Users/you/Logs/co_launchd_err.log</string>
</dict>
</plist>

Load it with launchctl load ~/Library/LaunchAgents/com.studio.co_batch_export.plist. Omitted StartCalendarInterval keys act as wildcards, so the job fires at 02:00 every day — see Apple's Creating launchd Jobs reference. Note that the macOS GUI must be logged in and awake at 02:00 for AppleScript to drive Capture One; enable Energy Saver's keep-awake and run one dry run before you rely on the schedule.

Overnight acceptance checklist and output verifier

Run the Capture One job manually once, then automate. Tick each item before you leave the studio:

• Session folder copied; find … | wc -l counts match on both machines.
• Both recipes enabled in the export picker; test on 10 variants first.
• Free disk ≥ (RAW set + expected TIFF output) × 1.3.
• Script Editor dictionary confirms the AppleScript verb your build uses.
• launchctl list | grep co_batch_export shows the agent loaded.
• Energy Saver → Prevent automatic sleeping when the display is off: on.
• Capture One license activated for this machine; sign-in not expired.

Then verify the output before you download:

#!/bin/bash
# verify_export.sh — run on the rented Mac after export completes
set -euo pipefail

RAW_DIR="$HOME/Sessions/ClientName_2026-11-10/Capture"
OUT_DIR="$HOME/Sessions/ClientName_2026-11-10/Output"
RAW_EXT="CR3"
OUT_EXT="tif"
MIN_MB=20

raw=$(find "$RAW_DIR" -iname "*.${RAW_EXT}" | wc -l | tr -d ' ')
out=$(find "$OUT_DIR" -iname "*.${OUT_EXT}" | wc -l | tr -d ' ')
printf 'RAW source : %s\nTIFF output: %s\n' "$raw" "$out"

if [ "$raw" -ne "$out" ]; then
  echo "FAIL: count mismatch — inspect Capture One export log."
  exit 1
fi

small=$(find "$OUT_DIR" -iname "*.${OUT_EXT}" -size -"${MIN_MB}"M)
if [ -n "$small" ]; then
  echo "FAIL: files below ${MIN_MB} MB (possible zero-byte export):"
  echo "$small"
  exit 2
fi
echo "PASS."

A passing run prints PASS.; any other outcome exits non-zero, so the launchd log makes an overnight failure obvious the next morning. Pair this with a short notification step at the end of the shell script if you want push alerts.

Choosing a Figment plan and checking the entry price

Capture One's RAW decode is CPU- and memory-hungry, and RAW previews chew disk. For a 2,000-file overnight batch, a physical Apple silicon plan is the sensible request.

Figment's physical plans are request-based until supply is confirmed; chip, RAM, disk and access method are fixed in the quote, not on the pricing page.

Entry-price check against CloudMac. CloudMac publishes a Mac mini M4 with 16 GB RAM and a 256 GB SSD at $99.99/month on the CloudMac pricing page; its 256 GB row is marked Reserve now, while the 512 GB and 1 TB rows show Fully reserved with no next allocation scheduled, so availability depends on which SKU you need. Figment's $95 is a starting monthly price for an unspecified M-series — treat it as a lower entry price, not a like-for-like M4/16 GB comparison, because the chip, RAM and disk are fixed in the quote. If you also need the overnight schedule, backups and monitoring handled for you, that work sits in Figment's $249 Managed Build Mac tier, which self-serve rentals don't include.

Working-disk worksheet for a 2,000-frame CR3 shoot:

• RAWs: 2,000 × ~35 MB ≈ 70 GB
• Capture One cache and previews: add ~20–30% of RAW volume
• TIFF 16-bit output: 2,000 × ~90–140 MB ≈ 180–280 GB
• Total working disk: ~300–400 GB

Ask for that capacity in the quote; disk is the single spec most likely to stop the job overnight. If you deliver JPEGs only, the TIFF line drops to ~2–10 GB and 256 GB is usually enough.

Request a configuration quote at Figment Mac Hosting, confirm storage, RAM and the exact chip, then move the session once the machine is ready.

Get started →

Related reading:

• Mac Intel Legacy Plugin Compatibility
• Pre-Delivery Asset Validation on a Rented Mac
• GitHub Actions Self-Hosted Runner on a Mac