I Shot a 3D Tour on My iPhone and Had It Live in 45 Minutes — Here's the Exact Workflow

TL;DR: The thing that surprised me most when I first tried shooting a 3D tour with my iPhone 13 Pro was how fast it worked. I expected garbage — blurry depth maps, misaligned stitching, the usual "consumer tech trying to be pro" letdown.

📖 Reading time: ~32 min

What's in this article

1. The Problem: 3D Tours Used to Require a $5,000 Camera and a Production Team
2. What You Actually Need Before You Start
3. The Three Tools I've Actually Used (and Which One I Keep Coming Back To)
4. Option 1: Matterport — Full LiDAR Pipeline on iPhone
5. Option 2: Polycam Capture + Kuula Hosting — More Control, Better Pricing
6. Option 3: Roundme — Quickest Path from Photo to Published
7. Head-to-Head Comparison: Matterport vs Kuula vs Roundme
8. The 45-Minute Workflow I Actually Use for Client Deliverables

---

The Problem: 3D Tours Used to Require a $5,000 Camera and a Production Team

The thing that surprised me most when I first tried shooting a 3D tour with my iPhone 13 Pro was how fast it worked. I expected garbage — blurry depth maps, misaligned stitching, the usual "consumer tech trying to be pro" letdown. Instead, I had a walkable 3D space uploaded and shareable in under an hour. That's a genuinely different world from three years ago.

The reason this changed is specific: Apple put a LiDAR scanner in the iPhone 12 Pro and every Pro model since. LiDAR isn't a marketing word here — it's a time-of-flight depth sensor that fires infrared pulses and measures how long they take to bounce back. Matterport's Pro2 camera, which costs around $3,500, uses the same underlying principle. Your iPhone 15 Pro has one in its face. The depth data quality isn't identical, but for most business use cases it's well within "good enough to close a deal" territory.

The use cases where this actually pays off are pretty concentrated. Real estate agents are the obvious group — a 3D walkthrough on a listing keeps unqualified buyers from wasting everyone's time on in-person visits. Airbnb hosts who add interactive tours see higher booking rates because guests self-select based on accurate expectations. Retail showrooms can put their floor layout online before a customer commits to a trip. Event venues pitch spaces to corporate clients without flying anyone in. Architects show clients a finished space before construction starts, using scans of reference buildings or model mockups. In every one of these cases, the old workflow required hiring someone with a $5,000–$15,000 rig and scheduling a half-day shoot.

What this guide actually walks through is the end-to-end pipeline that requires zero desktop software and zero special hardware beyond an iPhone Pro. The flow is: capture the scan on-device using a dedicated app, upload raw scan data to a SaaS platform that handles meshing and hosting, then either embed the result on your site with an iframe or share a direct link. The most you'll touch a laptop for is copying an embed code. For a broader look at what SaaS tooling makes sense across different business operations in 2026, the Essential SaaS Tools for Small Business in 2026 guide is worth bookmarking — several tools in that list overlap with the 3D tour space in useful ways.

The honest trade-off upfront: iPhone LiDAR has a reliable range of roughly 5 meters for dense depth data. Large open spaces — a hotel ballroom, a warehouse — will need multiple scan positions stitched together, and some platforms handle that better than others. Rooms under 50 square meters? Nearly perfect on the first try. That's the sweet spot, and it covers most of the highest-value use cases anyway.

What You Actually Need Before You Start

The biggest misconception I see from people starting out: they think they need a DSLR rig and a Ricoh Theta to do any of this professionally. I shot my first publishable tour with an iPhone 14 Pro and Polycam on a Saturday morning. The LiDAR scanner on modern iPhones is genuinely good enough for real estate walkthroughs, small commercial spaces, and personal projects.

LiDAR is the real hardware dividing line here. iPhone 12 Pro and later (Pro and Pro Max lines only — not the standard iPhone 12) have it. The quickest check isn't digging through Settings — just look at the rear camera module. If you see three lenses plus a small dark dot that looks like it belongs to a different cluster, that's the LiDAR scanner. You can confirm via Settings → General → About and cross-reference your model number on Apple's spec pages. Standard iPhone models (12, 13, 14, 15 — non-Pro) do not have LiDAR. If that's what you're working with, you're not blocked, but your workflow shifts to manual photogrammetry or 360 photo stitching, which takes more time and produces different output.

The three capture apps worth knowing about right now:

• Matterport iOS app — free to capture, but hosting costs money fast. The free tier gives you one active space. Their Starter plan runs $9.99/month for 5 spaces as of early 2025. The capture quality is excellent and their platform outputs the most "polished" tours out of the box, but you're locked into their ecosystem.
• Polycam — my current go-to for anything I want to export. The LiDAR scan mode on iOS is fast, and you can export GLTF, OBJ, or equirectangular panoramas on the paid plan ($19.99/month or $139.99/year). The free tier lets you scan but limits export formats, which is the real friction point.
• RoomScan LiDAR — stronger on floor plan output than photorealistic walkthroughs. Useful if your end goal is 2D floor plans alongside a tour, not if you want immersive photo-quality renders.

The term "interactive 3D tour" gets thrown around loosely, so here's what it actually means in SaaS tooling terms: you're combining three layers. First, an equirectangular image set — panoramic images (or point cloud renders) formatted as 2:1 ratio images that map onto a sphere. Second, a hotspot layer — clickable navigation points that connect scenes, trigger info panels, or link to external URLs. Third, hosting with an embed layer — a URL or iframe snippet your client drops into their site. That's the full stack. Some tools (Matterport, Kuula, Momento360) bundle all three. Others (like using Pannellum open-source) let you own each layer separately. Knowing this breakdown matters because it tells you exactly where your data lives and what it costs to move it.

One thing that caught me off guard early: the file sizes. A single high-quality equirectangular panorama from an iPhone 14 Pro processed through Polycam can sit at 80–120MB before any compression. A 10-room tour is a gigabyte of source material before you've touched hosting. Factor that into your workflow — you'll want a fast upload connection and you'll want to understand what the SaaS platform does to compress your images before serving them to end users.

The Three Tools I've Actually Used (and Which One I Keep Coming Back To)

Matterport: Impressive Until the Invoice Arrives

I used Matterport first because everyone does. The capture quality from an iPhone 12 Pro with LiDAR was genuinely good — room stitching was accurate, the dollhouse view worked without any manual adjustment, and the embed code they give you is clean. But the free tier caps you at one active space. One. If you archive it, you can publish another, but that space is gone from public view. For anyone building a portfolio of tours or doing client work, you hit the wall inside the first week. Their Starter plan runs $9.99/month for 5 spaces and 10K monthly visitors, and the Pro plan at $69/month bumps you to 25 spaces. The visitor caps are the part that sneak up on you — a single tour that goes viral on Reddit will burn through 10K visits in an afternoon.

Kuula: The One I Keep Coming Back To

Kuula doesn't require LiDAR or any special hardware. You shoot 360 photos with a compatible camera or even stitch them manually, upload the equirectangular JPEGs, and the platform handles the rest. I switched to it for a client project where we were using a Ricoh Theta instead of an iPhone, and the workflow was noticeably faster than Matterport's. The embedding is more flexible too — you get hotspot controls, custom branding on paid tiers, and the iframe embed doesn't force a Kuula watermark into the viewer on their Pro plan ($16/month). Free accounts get unlimited tours but with branding, which is actually usable for personal projects. The thing that surprised me: you can upload a batch of 360 images and link them into a tour with hotspot navigation in about 20 minutes without touching any code.

<!-- Kuula embed — replace TOUR_ID with your actual tour hash -->
<iframe
  src="https://kuula.co/share/TOUR_ID?fs=1&vr=0&zoom=1&initload=0&thumbs=1&info=1&logo=0"
  style="width:100%;height:600px;border:none;"
  allowfullscreen
  allow="xr-spatial-tracking"
></iframe>

The logo=0 param only suppresses the logo on Pro — if you're on free it just gets ignored. Learned that after a client demo went sideways.

Polycam: The Capture Side Is Where It Wins

Polycam is not a hosting platform — it's a capture and processing app, and it's the best one I've used on iPhone. On any iPhone with LiDAR (12 Pro and later), it builds a 3D mesh in real time as you walk around a space. The LIDAR mode produces a textured mesh you can export as .glb, .obj, .usdz, or point cloud formats. The 360 Photo mode works on non-LiDAR phones too, capturing a panorama you can push directly to Kuula or embed yourself. Pricing is $19.99/month or $179/year for the Pro plan, which unlocks high-res exports and removes the polygon caps on mesh exports. Free tier exports are capped at around 100K polygons, which is fine for previews but looks rough on a 4K monitor.

The workflow I actually run looks like this: capture in Polycam → export as .glb → host on a Matterport-alternative like Kuula or self-host with model-viewer web component if the client wants full control:

<!-- model-viewer web component, requires @google/model-viewer -->
<script type="module" src="https://unpkg.com/@google/model-viewer/dist/model-viewer.min.js"></script>

<model-viewer
  src="/tours/living-room.glb"
  alt="3D scan of living room"
  camera-controls
  auto-rotate
  shadow-intensity="1"
  style="width: 100%; height: 600px;"
></model-viewer>

Self-hosting the GLB gives you zero per-visit fees and no platform dependency, but you're also handling your own CDN, and a high-res GLB can run 150–400MB depending on scan complexity. That's not a problem if you're already paying for Cloudflare R2 or Backblaze B2, but it's not "free" either.

Honest Comparison: Which Tool for Which Situation

• Client deliverable with a budget: Matterport Pro if they want the brand recognition and will pay for it. The output is polished and clients recognize the interface.
• Personal portfolio or small agency work: Kuula Pro at $16/month is genuinely the best value. Flexible embedding, no hardware lock-in, and the tour editor doesn't require a tutorial to figure out.
• Developer building a custom viewer: Polycam for capture, export GLB, self-host with model-viewer. Full control, no recurring platform fees beyond the Polycam subscription.
• Non-LiDAR iPhone or older Android: Kuula wins by default — it accepts any equirectangular 360 image. Polycam's LIDAR mode isn't available and Matterport's quality drops noticeably without the depth sensor.

Option 1: Matterport — Full LiDAR Pipeline on iPhone

Matterport's iPhone app genuinely impressed me the first time I used it — the real-time mesh overlay as you walk a room is not a gimmick, it's actually how you know if your scan is going to be garbage before you upload. That feedback loop is the whole reason I'd recommend it over competitors for first-timers.

Download is free from the App Store and capture is free. The app uses your iPhone's LiDAR sensor (iPhone 12 Pro and newer — no LiDAR, no proper depth scan) and the capture UI is built around "blue dots" appearing on your screen as you pan around. Your job is simple: move to a new position, plant your feet, slowly pan 360°, wait for the dots to fill in, then walk to the next spot. The mesh builds visibly in real time — you'll see grey geometry appear as depth data locks in. If a section looks thin or patchy on the mesh preview, you haven't captured enough from that angle. Step closer, re-pan. This is much faster to learn from the visual feedback than from any written guide.

The thing that caught me off guard: the app punishes fast movement hard. If you walk between scan positions while the LiDAR is still processing, or if you speed-walk across a large room, you'll get an "alignment failed" error for that section. The fix is to literally stop walking, wait for the current scan point to complete (the blue dots go solid), then move. The sweet spot is about 1–1.5 meters between scan positions for a typical living room. Go farther than that between stops and you risk gaps. I rescanned a hallway twice before I learned to just slow way down.

Once you're done, hit "Upload" inside the app. The model uploads to Matterport Cloud and processing takes roughly 5–20 minutes depending on scan complexity — a single bedroom is closer to 5, a full apartment with multiple rooms runs 15–20. When it's done, you get four things that are actually useful:

• Dollhouse view — a floating 3D cutaway of the whole space you can orbit with a mouse or finger
• Floor plan — auto-generated 2D overhead with room labels you can edit
• Measurable model — click any two points and get a distance reading, useful for clients checking if a couch fits
• Shareable link + embeddable iframe — one click to copy either

The embed code is exactly what you'd expect — paste your model ID and drop it in any CMS or static page:

<iframe
  src="https://my.matterport.com/show/?m=YOUR_MODEL_ID"
  width="853"
  height="480"
  frameborder="0"
  allowfullscreen
  allow="xr-spatial-tracking"
></iframe>

The xr-spatial-tracking permission matters if you want the VR mode to work on Quest headsets — I missed that the first time and wondered why the VR button was greyed out for a client. Also add ?play=1 to the URL if you want the tour to auto-start instead of showing the splash screen.

Free tier reality: as of my last check, Matterport's free plan allows 1 active space. You can create new spaces but you'd need to archive (deactivate) old ones to stay within the limit. Since pricing changes frequently, confirm the current limits at matterport.com/pricing before you build a workflow around it. Paid plans start around $65/month and unlock multiple active spaces plus analytics and MLS embedding — worth it if you're doing real estate work at volume, overkill for a one-off project.

Option 2: Polycam Capture + Kuula Hosting — More Control, Better Pricing

The thing that surprised me most about this combo is how cleanly the two tools complement each other's weaknesses. Polycam's export quality beats Matterport's iPhone capture hands-down, but Polycam's own hosting is basic — you can share a link but you can't customize much. Kuula is basically the opposite: the capture side doesn't exist, but the hosting and presentation layer is genuinely good. Put them together and you've got a real production pipeline.

Capturing in Polycam: 360 Photo Mode, Not Room Scan

This tripped me up the first time. Polycam has two relevant modes — "Room Scan" (LiDAR-based, makes a 3D mesh) and "360 Photo" (equirectangular panoramas). For Kuula hosting, you want 360 Photo mode exclusively. Room Scan exports a point cloud or mesh, not the equirectangular JPEG that Kuula expects. I wasted about an hour on my first project before I figured that out. In 360 Photo mode, Polycam stitches from your iPhone camera using gyroscope-assisted capture — you rotate slowly through the space, it does the stitch on-device, and you get a single wide panoramic image that maps perfectly to a sphere.

Export Settings That Actually Matter

When you export from Polycam, two settings make a visible difference in final quality:

• Resolution: 8K if your Polycam plan supports it. The free tier caps you lower. At 8K (8192×4096px), your viewer can zoom in on shelf labels, product details, signage — stuff that matters for retail. Drop to 4K and it feels like a blurry screenshot.
• JPG quality: 95 or above. Anything below 90 and you'll see compression artifacts in gradients — ceilings, windows, lit display cases. These are exactly the surfaces that expose compression the most.

Export as equirectangular JPEG. The file will be somewhere between 8–25MB depending on the space. That's expected — don't try to optimize it down before uploading, Kuula handles its own progressive delivery.

Importing to Kuula and Building the Tour

Drop your equirectangular images straight onto the Kuula upload area at kuula.co. It recognizes the 2:1 aspect ratio automatically and previews them as spheres — no configuration needed. Once all your panoramas are uploaded, you create a "Tour" object and add them in sequence. The order matters because it controls your default navigation flow, but users can jump between any two panoramas once hotspots are set.

Adding hotspots took me about 10 minutes to get comfortable with the UI — not because it's bad, but because the click target for "add hotspot" is small and I kept accidentally moving the panorama instead. The workflow is: double-click the spot in the panorama where you want the transition arrow → select "Link to panorama" → pick the destination from your tour list. You can also adjust the hotspot icon style (arrow, dot, custom image) and set the landing view angle on the destination panorama, which is a nice touch — your viewer arrives facing the right direction instead of a random wall.

Kuula Pricing: What the Free Tier Actually Gets You

The free tier is real but limited. Check kuula.co/pricing for current numbers since they update it, but the hard blockers are the tour count cap and the Kuula watermark on all embeds. For personal projects or demos, that's fine. For client work — especially retail — the watermark is a dealbreaker. I moved a client project to Kuula Pro specifically because it lets you add a custom logo and strip the Kuula branding entirely. The Pro plan also unlocks Google Analytics integration, which the client's marketing team actually used.

Real Production Use: Retail Space Walkthrough

I used this stack for a client's boutique retail space — roughly 1,200 sq ft, four distinct zones (entrance, main floor, fitting area, checkout). Here's roughly what the full workflow looked like:

1. Captured 11 panoramas in Polycam 360 Photo mode — about 25 minutes of shooting including repositioning between spots
2. Exported at 8K / 95% JPG quality — total upload batch was ~180MB
3. Imported to Kuula, built the tour structure, added hotspots between adjacent zones — about 45 minutes including tweaking landing angles
4. Added client logo via Kuula's branding settings, turned off Kuula watermark (Pro plan)
5. Embedded the tour in their Shopify store using Kuula's iframe embed code

<!-- Kuula embed — swap YOUR_TOUR_ID for the actual ID from your tour URL -->
<iframe
  width="100%"
  height="600"
  style="border:none;"
  allow="xr-spatial-tracking; gyroscope; accelerometer"
  allowfullscreen
  src="https://kuula.co/share/collection/YOUR_TOUR_ID?fs=1&vr=1&gyro=1&logo=1&info=1&thumbs=1">
</iframe>

The gyro=1 flag is worth keeping — it enables gyroscope navigation on mobile, which is what makes it feel like an actual 3D experience rather than a drag-to-look panorama. The client's team could update the tour themselves by uploading replacement panoramas through Kuula's dashboard without touching the embed code.

Option 3: Roundme — Quickest Path from Photo to Published

Roundme surprised me because it stripped out everything I didn't need. I had equirectangular JPEGs already exported from my iPhone's 360° mode via the Google Street View app, and Roundme just accepted them — no proprietary format, no special rig, no preprocessing step. Most tools make you feel like you need $3,000 in hardware before you're allowed to start. Roundme doesn't care where your equirectangular image came from as long as the projection is correct.

Uploading is genuinely fast. On the web interface, you drag your equirectangular image in, wait about 20–30 seconds for the spherical preview to render, then drag the horizon line if your nadir/zenith is off. The iOS app does the same flow — shoot, upload, set your initial viewing angle (the exact yaw/pitch where the tour "opens"), and hit publish. That's the whole process for a single scene. For a multi-scene tour, you link scenes together manually, which takes maybe 5 minutes once you know the UI.

# If you're preparing images outside the app, this is the spec Roundme expects:
# Format: JPEG or PNG
# Projection: Equirectangular
# Aspect ratio: 2:1 (e.g. 8192x4096 is their recommended max)
# Color space: sRGB
# Nadir patch: optional, they won't reject the image without it

# Quick ImageMagick check on your export before uploading:
identify -verbose your_360.jpg | grep -E "Geometry|Type|Colorspace"
# Should read: Geometry 8192x4096, Type TrueColor, Colorspace sRGB

The free tier is legitimately usable — you get unlimited public tours with no scene cap hidden behind a paywall. Kuula's free plan caps you at 5 panoramas total across your account before pushing you toward the $16/month Pro tier. Roundme's free limit is more about branding removal and privacy controls than raw scene count, so for basic portfolio work or client previews, you won't hit a wall quickly. The paid plan runs around $9.99/month if you need private tours or white-label embeds.

Where I felt the friction: the hotspot editor is weak. You get basic link hotspots between scenes and that's more or less it. No info cards with rich HTML, no embedded video popups, no custom icon sets. Compare that to Kuula where you can drop in YouTube embeds, styled text cards, and custom SVG icons per hotspot. Roundme's UI also hasn't had a visual refresh in a while — the panel layout feels like a 2016 SaaS product, and the mobile preview button sometimes lags behind your edits. None of this breaks the tool, but it does mean you spend more time fighting the interface than actually building the tour.

There's also no floor plan overlay. Matterport gives you that dollhouse/floor plan navigation hybrid that clients in real estate specifically ask for. Roundme has no equivalent — users navigate purely by clicking arrows in the scene. For a property walkthrough where orientation matters, that's a real missing feature. For a restaurant tour, a hiking trail highlight, or an event space preview where people just want the feel of the space, it genuinely doesn't matter. Match the tool to the use case. If your client opens the demo and immediately asks "where does this room connect to the rest of the floor?", use something else.

Head-to-Head Comparison: Matterport vs Kuula vs Roundme

The thing that catches most people off guard is that Matterport and Kuula aren't really competing for the same user. Matterport is a capture-to-publish pipeline built around its own hardware. Kuula and Roundme are publishing platforms — they expect you to show up with 360° photos already in hand. Once I understood that split, the comparison got a lot cleaner.

Capture Method

Matterport's full 3D mode requires LiDAR — either a Matterport Pro2/Pro3 camera or an iPhone 12 Pro and newer using the Matterport iOS app with LiDAR enabled. Without LiDAR you get a 360° photo walkthrough, not a true 3D mesh. The dollhouse view and floor plan are generated from that mesh, so if you skip LiDAR, you're not getting Matterport's headline feature. Kuula and Roundme take any equirectangular JPEG you throw at them — shot on a Ricoh Theta, an Insta360, or even a phone with a fisheye lens stitched in Hugin. The tradeoff is that capture quality is entirely your problem. Matterport's pipeline is opinionated because it controls the capture device; the other two have zero opinions and zero guardrails.

Free Tier Reality Check

• Matterport: 1 active space on the free plan. Not 1 per month — 1 total, ever live at once. For anyone doing multi-property real estate or a portfolio of client work, this is a non-starter immediately.
• Kuula: Free tier tours carry a Kuula watermark and you're capped on the number of published tours. Paid plans start around $16/month and remove branding. The watermark situation alone will kill it for client-facing work on the free plan.
• Roundme: Their limits shift — check roundme.com directly for current pricing. I've seen it change at least twice in 18 months. Don't plan a project around tier limits you found in a blog post from 2023.

Embed Customization and Dollhouse View

Kuula is the clear winner on embed flexibility. Their iframe parameters are actually documented (rare enough to be worth calling out), you can point tours at a custom domain on paid plans, and branding removal is clean. I've used their &fs=0&vr=0&zoom=1&thumbs=-1 style parameters to strip down embeds for minimal client-facing pages without touching JavaScript. Matterport embeds work but the customization is limited unless you're on a business plan and using their SDK. Roundme's embed is functional but basic — you get an iframe and that's mostly it.

The dollhouse and floor plan view is Matterport-exclusive and it's genuinely impressive when the LiDAR scan is clean. If a client specifically asks for that bird's-eye walkthrough experience, Kuula and Roundme simply can't deliver it. No workaround exists. That one feature justifies Matterport's pricing for the right use case — commercial real estate, architecture, insurance documentation.

Processing Time

Matterport is async by design. After you capture and upload from the app, you're waiting 10–20 minutes for cloud processing before the tour is live. On a busy day I've seen it stretch longer. Kuula and Roundme are near-instant — upload your 360 JPEG, add hotspots, publish. If you're doing same-day delivery for a client, that processing lag in Matterport is a real workflow constraint, not just an inconvenience.

The Dealbreaker Per Tool

• Matterport: The 1-active-space free tier makes it unusable for any multi-property workflow. The moment you have two clients, you're paying. The Starter plan at $9.99/month gets you 5 active spaces, which is also surprisingly low for agency work.
• Kuula: Capture is 100% your responsibility. If your 360° photos have stitching errors, bad exposure, or ghosting from movement, Kuula has no mechanism to fix that. The platform is a publisher, not a processor. This bites people who assume uploading to a SaaS tool will clean up mediocre source files.
• Roundme: The hotspot system is genuinely basic. You can link scenes and add info points, but compared to Kuula's hotspot editor — which supports custom icons, external URLs, embedded media, and conditional behavior — Roundme feels like version 0.8 of the same idea. If you want rich interactive storytelling inside a tour, Roundme will frustrate you quickly.

The 45-Minute Workflow I Actually Use for Client Deliverables

The first time I delivered a 3D tour to a client, I spent three hours fiddling with settings I didn't need to touch. Now I'm done in 45 minutes flat, including the upload. Here's the exact sequence I follow, broken down by what's actually happening at each step.

Minutes 0–20: Capture Phase in Polycam

Open Polycam, switch to 360 Photo mode (not LiDAR, not 3D Scan — 360 Photo). For an average bedroom or living room, I shoot 8–12 positions. Larger open-plan spaces need 13–15. The rule I follow: move every 6–8 feet and never skip corners — that's where clients always want to look first and where gaps are most obvious. Hold the phone steady for the 2–3 second capture, rotate slightly before moving to the next position. Don't rush this part. Blurry captures don't fix themselves downstream.

The lighting thing caught me off guard on my third shoot. Direct sunlight punching through a window will blow out the stitching around that window — Polycam's algorithm doesn't handle high dynamic range transitions well, and you end up with a smeared white blob where the window frame should be. Shoot with blinds half-down or wait for overcast conditions. Ambient light from a cloudy sky gives you clean, even stitching every time. Bright overheads work fine. Afternoon sun through south-facing windows does not.

Minutes 20–25: Export From Polycam

This is where most people burn time on their first delivery. Inside Polycam, go to your capture and hit Share/Export. You'll see multiple export options — select "360 Photo" and export as equirectangular JPG. Do not select the 3D Mesh export by accident. They look similar in the UI but output completely different file types. The mesh gives you a GLTF or OBJ that Kuula can't use. The 360 Photo gives you a 2:1 ratio JPG that every tour platform understands immediately. I've made this mistake, sent the wrong file to a client, and had to reshoot. Now I check the filename after export — equirectangular JPGs from Polycam will have dimensions around 6080×3040 or similar 2:1 ratio. If the file is 50MB and looks like a warped room, you're in good shape.

# Quick sanity check on your exports before uploading
# Run this in terminal if you have exiftool installed
exiftool IMG_0023.jpg | grep -E "Image Size|Projection Type"

# Expected output for a valid equirectangular:
# Image Size: 6080x3040
# Projection Type: equirectangular

Minutes 25–35: Kuula Setup

Drop all your equirectangular JPGs into a Kuula upload in one batch. The free tier allows unlimited uploads but watermarks embeds — the Pro plan is $16/month and removes watermarks plus unlocks custom domains. For client work, Pro is non-negotiable. Once uploaded, arrange your frames in the sequence a visitor would naturally walk through the space. I always start at the entrance, move to the main living area, then branch to secondary rooms. In Kuula's editor, add hotspot arrows between frames to let users navigate — click the hotspot tool, point it toward the doorway leading to the next room, link it to that frame. Takes about 45 seconds per room transition once you've done it twice.

Minutes 35–40: Polish Before Delivery

Set the start position by centering the initial view on the most visually appealing part of your entrance frame — not a wall, not a ceiling. Kuula lets you drag the viewport and lock a default view angle. Export a thumbnail from that same frame. Add the tour title using whatever naming convention the client wants (I use "PropertyAddress_Date" internally and their preferred branding publicly). This step feels optional but clients notice when the embed starts pointed at a blank wall.

Minutes 40–45: Deliver

Kuula generates a shareable link and an embed iframe. The embed code looks like this:

<iframe
  src="https://kuula.co/share/collection/XXXXXXX?logo=1&info=1&fs=1&vr=0&autorotate=0.3"
  width="100%"
  height="640"
  frameborder="0"
  allow="xr-spatial-tracking"
  allowfullscreen>
</iframe>

The autorotate=0.3 parameter gives a slow drift on load that looks polished without being annoying. Drop this into the client's WordPress page, Webflow CMS field, or paste the link directly into an email if they just want to share it. Either works. The link is mobile-friendly by default, which is usually the first thing clients test on their phone before saying anything else.

When to Pick Which Tool

The honest answer is that most of the "which tool is best" debates online are written by people who haven't actually billed a client for a 3D tour. I've run into situations where the wrong tool choice costs you a reshoot, and that's the thing worth optimizing against — not feature checklists.

Matterport: Real Estate, Full Stop

If your buyer is a real estate agent or a property manager whose clients already know what a Matterport dollhouse view looks like, you need Matterport. Not because the tech is objectively superior, but because expectations are set. A buyer walking through a Zillow listing who clicks "3D Tour" and gets something that doesn't have the dollhouse toggle or the measurement tape tool will notice, and your agent client will hear about it. Matterport's Pro2 or iPhone-based Capture app with their subscription (~$69/month for the Pro tier as of 2024) makes sense the moment your client is paying the hosting bill, not you. The moment you're absorbing that cost across five properties a month, the math breaks.

Polycam + Kuula: Volume Work and White-Label Clients

I switched to this combo for multi-property workflows because Polycam's LiDAR capture on iPhone 12 Pro and newer is genuinely fast — I can walk a 1,500 sq ft apartment in under 10 minutes and export a usable mesh or equirectangular panorama — and Kuula's embedding is flexible enough that I can drop it into a client's WordPress site without their visitors ever seeing Kuula's branding. Kuula's Pro plan is $16/month and removes the watermark. That's the threshold that matters. Polycam has a $7.99/month tier that unlocks HD exports and GLTF/OBJ downloads if you need the raw mesh for something downstream. The combination gives you faster iteration than Matterport's capture-to-publish pipeline, which involves waiting on their processing queue.

Roundme: One-Off Shots, No Fuss

Someone asked me last year how to get a 360 photo of their restaurant online in an afternoon without spending money. Roundme is the answer. You shoot a spherical photo with your iPhone using any 360 app (I've used Camera+ and the Insta360 X3 companion app), upload it to Roundme, and have a shareable link in minutes. The free tier lets you publish publicly with their branding. That's fine for a portfolio piece or a single venue listing where nobody's paying you for white-label delivery. Don't overthink it for this use case — Roundme exists exactly for this.

The Case Where None of These Work

LiDAR on an iPhone is doing structured-light depth estimation across a space and reconstructing geometry from overlapping frames. In a space smaller than roughly 10x10 feet — a bathroom, a walk-in closet, a server room alcove — the scan comes back looking like someone smeared vaseline on the walls. The point cloud is too dense relative to the volume, reflective surfaces (mirrors, glass, tile) blow out the depth data, and you end up with a mesh that looks worse than a bad photo. I've tried to salvage small-space scans in RealityKit and Polycam's editor and it's not worth the hour you'll spend. For tight spaces, shoot a standard wide-angle photo or a short video walkthrough and call it done.

Common Issues and How to Actually Fix Them

The thing that surprises most people their first time doing this: 90% of 3D tour failures aren't hardware problems. Your iPhone is fine. The issues are almost always about how you moved between positions or what was moving in the room while you shot. I've debugged enough broken tours to tell you exactly what's going wrong and how to fix it without reshooting the entire space.

Matterport Alignment Failures

When Matterport drops a scan position or shows that jagged, disconnected mesh that looks like two different rooms got spliced together, the usual culprit is scan speed. The app needs to build a point cloud between positions so it can anchor the next scan relative to the previous one. If you walk too fast or skip too far across a room, the algorithm has nothing to anchor against. The fix is boring but it works: slow down to almost awkward slowness between positions, and make sure each new position overlaps the previous one by roughly 50% of what the camera can see. In a hallway, that means scanning roughly every 4–5 feet instead of every 8. In a large open room, start by doing a perimeter sweep close to the walls before filling in the center — you're giving the stitcher a continuous chain to follow rather than isolated islands.

Polycam Stitching Seams

Polycam's LiDAR stitching is impressive until you see the seam where two shots meet and there's a visible hard edge or color mismatch in the texture. The most common cause isn't the LiDAR data — it's the photographic texture layer, specifically inconsistent lighting or a moving object between captures. Ceiling fans are the classic offender. The fan blades appear in slightly different positions in each shot, and the texture blending algorithm has no idea how to reconcile that, so you get a ghost artifact or a hard tear. The fix is to reshoot just that transition zone: turn the fan off, wait for any people to clear the frame, and capture the overlap in a single continuous motion rather than stopping and restarting. If you're reshoooting one section in Polycam on iOS, make sure your ambient lighting hasn't changed from the original session — don't open a blind or turn on an overhead that was off before, because the texture color temperature will visibly shift at that seam.

Kuula Hotspot Position Drift After Upload

You placed a hotspot at what looked like the exact position during editing, but after uploading to Kuula, it's floating six inches off to the left of where you intended, or it's at the wrong height. This happens because Kuula's hotspot coordinate system maps directly against the equirectangular projection of your panoramic image — the flat 2:1 image the tour is built from. If your image was captured with any roll offset (the camera wasn't perfectly level), or if Kuula re-projected the image during processing, the coordinates shift. The actual fix is to not fight the coordinate system during initial setup. Upload first, then click-drag hotspots into position directly in the Kuula editor on the live preview sphere. That editor gives you real spherical coordinates against the final rendered output, which is the only coordinate space that actually matters. Trying to calculate exact positions before upload is a waste of time.

iframe Embeds Blocked on WordPress Sites

Your tour works perfectly on the direct URL, but the client's WordPress site shows a blank box where the iframe should be. Open the browser console and you'll see something like this:

Refused to frame 'https://my.matterport.com/' because an ancestor violates
the following Content Security Policy directive: "frame-ancestors 'self'"

That's a CSP header rejection, not a WordPress plugin conflict or an iframe syntax error. Many managed WordPress hosts (WP Engine, Kinsta, and some Cloudflare setups) add restrictive Content-Security-Policy or X-Frame-Options headers at the server level. The client needs to whitelist the tour platform's domain in their CSP. On Kinsta or WP Engine, this is typically done through the hosting dashboard's custom headers section, not through a WordPress plugin. The header you're adding looks like this:

Content-Security-Policy: frame-src 'self' https://my.matterport.com https://app.kuula.co https://poly.cam;

If they're on a host that doesn't expose header controls, the workaround is to use the platform's native embed JavaScript loader instead of a raw iframe — Matterport and Kuula both offer a JS SDK option that sometimes sidesteps CSP restrictions. It's not guaranteed, but it works often enough to try before escalating to the host's support team. Also worth checking: the Wordfence and iThemes Security plugins both add their own X-Frame-Options: SAMEORIGIN headers independently of the host, so disable those temporarily to confirm the source before you spend an hour on a support ticket.

---

Disclaimer: This article is for informational purposes only. The views and opinions expressed are those of the author(s) and do not necessarily reflect the official policy or position of Sonic Rocket or its affiliates. Always consult with a certified professional before making any financial or technical decisions based on this content.

---

Originally published on techdigestor.com. Follow for more developer-focused tooling reviews and productivity guides.