---
title: "Check-in and check-out inventory: compare two video scans"
description: "How a video check-in/check-out comparison works: what counts as added, moved or gone, why \"not seen\" is not \"gone\", and how to run it on a real example."
lang: en
date: 2026-10-11
tags: ["check-in", "check-out", "inventory", "short-term rentals"]
source_url: https://spacecontext.app/blog/check-in-check-out-inventory-comparison/
---

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

How a video check-in/check-out comparison works: what counts as added, moved or gone, why "not seen" is not "gone", and how to run it on a real example.

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:

| List | Meaning |
| --- | --- |
| `items.added` | In the later scan, matched to nothing in the earlier one |
| `items.moved` | The same item, recorded in another area |
| `items.quantity_changed`, `items.condition_changed` | Counted or assessed differently |
| `items.removed`, `issues.resolved` | **Confirmed**: a frame of the later scan shows the place without it, with a `note` and that frame |
| `items.not_seen`, `issues.not_seen` | In the earlier scan, not in the later one, not confirmed |
| `issues.new` | Issues the earlier scan did not have |
| `areas.condition_changed` | A room whose overall condition changed |

## 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:

```bash
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:

```json
"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:

```json
{
  "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](https://spacecontext.app/developers/console/), 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](https://spacecontext.app/developers/docs/guides/check-in-check-out/):

```bash
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):

```bash
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](https://spacecontext.app/developers/docs/api/skills-and-diff/).

**From an assistant.** Connect Claude, ChatGPT or Cursor to the [Space Context MCP server](https://spacecontext.app/blog/mcp-server-for-physical-spaces/) 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](https://spacecontext.app/developers/#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](https://spacecontext.app/blog/short-term-rental-guest-guide-from-video/).

## 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](https://spacecontext.app/developers/console/), or, if you would rather film with your phone, [download Space Context for iPhone](https://apps.apple.com/app/id6774555358).

## FAQ

### Does Space Context say an item is missing at check-out?

In the comparison of the console, CLI and API, only when a frame of the check-out scan shows the place where the item was, without it. Anything else the later scan did not show goes to a separate not_seen list: it may be gone, or it may simply not have been filmed. The iPhone app's comparison lists removed elements by name, without that photo check.

### What does a check-in/check-out comparison list?

Items added, moved, recounted or in another condition, issues that are new or fixed, area condition changes, and what the later scan did not show. Every entry links to the original frames of both scans, with their time in the video.

### Can I compare scans made with the iPhone app?

Yes. The app keeps a space's previous scans so you can compare before and after, and the same account can compare them in the console, the API or an assistant. Past app scans are matched by content, so nothing can be confirmed gone, and the API no longer serves their images.

### How much does a comparison cost?

Comparing is included; you pay for scans. Through the console, CLI or API the first live scan of an account is free once a card is on file, then each live scan costs $1.00 from prepaid credit. Test keys run the whole flow on the demo space for free.

### Is the comparison accepted as evidence in a deposit dispute?

It gives you the original, unretouched frames of both scans with their timestamps. Whether a platform, insurer or court accepts them depends on your contract and jurisdiction, so check with them before relying on it.