Check-in and check-out inventory: compare two video scans

A check-in/check-out inventory in Space Context is two scans of the same space and one comparison. You film the space before a stay, a move-in or a handover and again after it; the comparison lists what was added, moved, recounted or changed condition, which issues are new or fixed, and keeps what the later scan simply did not show in a separate not_seen list. In the comparison of the console, CLI and API, something is reported gone only when a frame of the check-out shows its empty place, and every entry links to the original frames of both scans.

In short

• Two scans plus one comparison give you what changed, with photos from before and after.
• removed and resolved are confirmed by a frame; not_seen means “go and check”, not “it’s gone”.
• When you scan a space again through the console, CLI or API, the new analysis is checked against the previous inventory, so the same sofa keeps its record.
• It works without code in the console, from the CLI, the API and the SDK, and from AI assistants over MCP. The iPhone app keeps scan history too.
• You can try it for free on the demo space: a real apartment, scanned at check-in and at check-out.

How does a check-in/check-out or move-in/move-out comparison work?

You record the space twice. At check-in you walk every room, open cupboards, film the appliances and say out loud anything already damaged (“small scratch on the table, already there”). At check-out you film the same space again, as the same space in Space Context, not a new one. Then you ask for the difference.

When you scan a space created through the API (the console and the CLI create them too) a second time, the analysis is given the previous scan’s inventory as a checklist. It links what it sees again (each item carries previous_item_id, each issue previous_issue_id) and records something as gone only with a frame of the empty place, in the document’s continuity field. The comparison of two consecutive scans uses those links and says so with "linked": true.

When the two scans are not consecutive, or the space was scanned with the iPhone app, records are matched by content: area names first, then each item’s generic name (canonical_name) in the same area, then items worded differently (a sideboard and a TV cabinet, a fan heater and a heater), never across categories. In that case nothing can be confirmed gone, so whatever is missing ends up in not_seen.

The answer of GET /spaces/{id}/diff keeps these lists apart:

Why is “not seen” not the same as “gone”?

Because a video shows only what the camera pointed at. A closed cupboard, a corner you walked past, a room filmed with the lights off: the object is not in the frames, but it may still be in the flat. AI analysis is also not perfectly repeatable. Two analyses of the same space never list exactly the same objects; in one of our tests, the same photos analyzed twice produced 34 and 20 objects.

A tool that called every missing record “removed” would have you accuse a guest or tenant of taking something the camera never looked at. So Space Context uses removed only with positive evidence, a frame of the later scan showing the spot, and puts everything else in not_seen. When an assistant reads a comparison through the MCP server, it is told to say that not_seen items may be missing.

The practical rule: treat not_seen as a list of things to check in person, and read coverage in both documents (weak coverage, unreadable labels, what was not shown) before drawing conclusions.

What does a real comparison look like?

The demo space is a one-bedroom apartment in Brisbane scanned twice through the API: five photos at check-in, then a 35-second narrated video at check-out (36 frames), checked against the check-in. The photos are by Chris Olszewski (Kgbo) on Wikimedia Commons, CC BY-SA 4.0; the demo’s narration is invented for the example. Any free test key can read it:

npx spacecontext login --test
npx spacecontext scans spc_demo                                  # scn_demo (current) and scn_demo_previous
npx spacecontext diff spc_demo --from scn_demo_previous --json

The summary it returns:

"level": "deep",
"linked": true,
"summary": {
  "areas_added": 0, "areas_removed": 0,
  "items_added": 5, "items_removed": 0, "items_not_seen": 0,
  "items_moved": 0, "items_changed": 0,
  "issues_new": 2, "issues_resolved": 0, "issues_not_seen": 1
}

What it says, list by list:

• Two new issues. “Loose heater cable” in the bathroom, severity high, and “Loose bedroom electrical cable”, severity medium.
• One room changed condition. The bedroom went from good to fair.
• Two issues found again, so neither new nor fixed. The loose hairdryer cable and the possible darkening on the shower frame were linked to their check-in records.
• One issue not seen. “Loose cable beside living-area cabinet” was in the check-in and not in the check-out. The video may not have pointed at that corner, or someone tidied the cable. The comparison does not guess.
• Five items added. A refrigerator, an electric kettle, a capsule coffee machine, two waste bins and a spare blanket.
• Nothing removed, nothing not seen. Everything recorded at check-in was found again.

Two of these need careful reading, and they show why you should read a comparison against the evidence:

• “Added” is not “brought in”. The check-in was five photos, and its own coverage warning says “Kitchen appliances are only partly visible”. The refrigerator was most likely there; nobody photographed it. The narrated check-out video showed the kitchen counter, so the appliances were recorded then.
• The heater did not “go from good to damaged”. The check-in photos never assessed it (condition unknown), and unknown is not an assessment, so the comparison does not report a condition change. It reports the loose cable as a new issue, and the check-out document records the heater as damaged (“The power cable is visibly loose.”).

What evidence do you get for each change?

Every entry carries evidence.from and evidence.to: the frames of each scan that show it, each with its time in the video and a URL (signed for your own spaces, and null when your key may not see that image). For something gone, to is the photo of the empty place. This is the heater issue from the demo comparison:

{
  "title": "Loose heater cable",
  "area": "Bathroom",
  "severity": "high",
  "evidence": {
    "from": [],
    "to": [
      { "frame_id": "frame-28", "timestamp_ms": 28087, "url": "https://spacecontext.app/demo/brisbane/checkout/frame-28.jpg" },
      { "frame_id": "frame-30", "timestamp_ms": 30058, "url": "https://spacecontext.app/demo/brisbane/checkout/frame-30.jpg" },
      { "frame_id": "frame-31", "timestamp_ms": 31044, "url": "https://spacecontext.app/demo/brisbane/checkout/frame-31.jpg" }
    ]
  }
}

Three frames, at 28.1, 30.1 and 31.0 seconds into the check-out video. The frames are the originals, never retouched. Signed links expire, so read the comparison again for fresh ones.

You can open the same comparison in the console with no code at all: get a free test key, switch to Test and open the demo space’s History & compare tab.

How do you run a check-in/check-out comparison on your own space?

In the console. Open New scan and drop the check-in video or photos. After the stay, open the space, go to History & compare, choose Scan again and drop the check-out video. The tab then compares any two scans you pick.

From the CLI, as in the check-in/check-out guide:

npx spacecontext scan checkin.mp4 --name "Flat 4B — Rossi stay" --type apartment
npx spacecontext scan checkout.mp4 --space spc_3f…
npx spacecontext scans spc_3f…                                # the two scan ids
npx spacecontext diff spc_3f… --from scn_checkin…            # add --json for the full answer

From the API, once both scans are complete (to defaults to the current scan):

curl "https://api.spacecontext.app/v1/spaces/spc_3f…/diff?from=scn_old…&to=scn_new…" \
  -H "Authorization: Bearer $SPACECONTEXT_API_KEY"

The SDK has the same call, sc.spaces.diff('spc_…', { from: 'scn_old…' }). The fields are described in Skills and comparisons.

From an assistant. Connect Claude, ChatGPT or Cursor to the Space Context MCP server and ask: “Compare the check-in and check-out scans of Flat 4B and list anything damaged or missing, with photos.” The server also has a check_out_report prompt: it calls compare_scans and writes a report in three parts, confirmed changes, possibly missing (never stated as gone), and items added, moved, recounted or in another condition.

How should you film so the comparison is fair?

• Film the check-out the way you filmed the check-in: same rooms, same order, cupboards open. What the camera does not show ends up in not_seen, never in removed.
• Turn the lights on and walk slowly. In a scan made through the console, CLI or API, blurred, dark or covered frames are left out of the analysis.
• Say what you see. Name rooms as you enter them and point out damage out loud; the narration is transcribed and tied to the right area.
• Keep both scans. Deleting the space deletes its history.

Through the console, CLI or API a video can be up to 4 GB and 10 minutes, or you can upload up to 120 photos. Ten minutes of a phone’s default 1080p recording come to about 1.2 GB, well within the limit.

Can you do this with the iPhone app?

Yes. When you scan a space again in the Space Context app, the new analysis becomes the current one and the previous one stays in the space’s history, so you can pick a past scan and compare it with the current one, before and after. The app’s comparison sets the two analyses side by side (elements added and removed, issues new and resolved, areas whose condition changed); it does not confirm with a frame that something is gone, so check any “removed” element against the images before raising it with a guest or tenant.

The same account sees those spaces in the console, the API and over MCP, at no extra cost. Two limits apply there. Past app scans are matched by content, so nothing can be confirmed gone. They are also not screened for sensitive values, so comparing them through the API or an assistant needs a key or connection allowed to see sensitive values, and their frames come without image links, because a later recording replaced them. If you need the photos of both sides through the API, scan with the console, CLI or API.

What does it cost?

Comparing, reading, searching and asking are included. In the console, CLI and API, a test key is free; the first live scan of an account is free once a card is on file (adding it charges nothing), and each live scan after that costs $1.00 from prepaid credit, with failed scans refunded to the balance. See pricing. In the app, scans use credits or the optional Space Context Pro subscription (€9.99 a month or €69.99 a year, 20 scans a month).

Want the same space to answer guests’ questions too? See how to turn a walkthrough into a guest guide.

Start with the demo, then your own space

Open the Brisbane demo in the console, read its comparison, then scan a real check-in. Get a free test key, or, if you would rather film with your phone, download Space Context for iPhone.