FOR SALE: Parsing a High-Rise with Mappedin MVF

JUST LISTED: The pinnacle of downtown Los Angeles living awaits you at 525 South Santa Fe Avenue!

Welcome, discerning buyers, to the most meticulously documented property listing you've ever seen. While other agents show you glossy brochures and vague square footage estimates, I've done something different. I've downloaded the building's entire digital twin and parsed every wall, hallway, and luxury amenity from its Mappedin MVF (Mappedin Venue Format) file.

Yes, I'm a real estate agent who reads GeoJSON for fun. Let me show you what I found.

The Numbers (Extracted Directly from the MVF)

Did I mention this building skips floor 13? Because of course it does. We're selling luxury, not superstition.

Floor-by-Floor Breakdown

The building layout tells an interesting story. Lower floors feature larger floor plates for amenities and commercial space, while upper floors are pure residential luxury:

• Levels 4-24: 16 units per floor (the workhorse floors)
• Levels 25-34: 14 units per floor (larger premium residences)
• Penthouse Level: Crown jewel status
• Roof Access (RA): Where the magic happens

Each unit is precisely mapped with interior walls, bedrooms, bathrooms, closets, and balconies. Unit numbers follow the classic [floor][unit] convention: apartment 2708 is the 8th unit on floor 27.

Amenities That Would Make Your HOA Weep

The MVF data reveals 26+ distinct amenity spaces. This isn't just a building; it's a vertical resort:

Wellness & Fitness

• Fitness Center
• Spinning Studio
• Spa & Spa Lounge
• Sauna Room
• Massage Room

Social & Entertainment

• Sky Lounge (because regular lounges are for ground-dwellers)
• Oculus Lounge
• Club Lounge
• Gallery Bar
• Theater
• Art Studio

Outdoor Escapes

• Roof Pool
• Second Pool (ground level, for variety)
• Cabanas
• Roof Terrace
• Dog Park (yes, on a high-rise)

Work & Productivity

• Co-Working Space
• Meeting Room
• Private Meeting Room
• Offices

Practical

• Mail Room
• Package Lockers
• Leasing Office

How I Got This Data

Here's where real estate meets software engineering. Mappedin exposes a REST API that lets you download the complete building data in MVF v3 format. Let me show you:

Step 1: Authenticate

const tokenResponse = await fetch(
  "https://app.mappedin.com/api/v1/api-key/token",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      key: "your-api-key",
      secret: "your-api-secret",
    }),
  }
);

const { access_token } = await tokenResponse.json();

Step 2: Download MVF

const mvfResponse = await fetch(
  "https://app.mappedin.com/api/v1/venue/67a6641530e940000bac3c1a/mvf?version=3.0.0",
  {
    headers: {
      Authorization: `Bearer ${access_token}`,
    },
  }
);

// API returns a CDN URL
const { url } = await mvfResponse.json();

// Download the actual ZIP
const mvfZip = await fetch(url);
const zipBuffer = await mvfZip.arrayBuffer();

Step 3: Parse with @mappedin/mvf

Here's where it gets elegant. Instead of manually unzipping and parsing JSON files, Mappedin provides the @mappedin/mvf library that handles validation, type safety, and parsing in one go:

npm install @mappedin/mvf

The library provides a typed parser that validates the MVF structure:

import { createMVFv3Parser } from "@mappedin/mvf";

// Create the parser
const parser = createMVFv3Parser()
  .build()
  .expect("Failed to build MVF parser");

// Parse the ZIP buffer directly
const bundle = await parser.decompress(zipBuffer);

// Now you have fully typed access to everything!
console.log(`Building: ${bundle.manifest.features[0].properties.name}`);
console.log(`Floors: ${bundle.floors.features.length}`);

The parsed bundle gives you typed access to all MVF extensions:

// Count apartments from locations
const apartments = bundle.locations?.filter((loc) => {
  const name = loc.details?.name;
  return name && /^\d{2,4}$/.test(name);
});
console.log(`Total apartments: ${apartments?.length}`);
// Output: Total apartments: 466

// Analyze floor structure
bundle.floors.features
  .sort((a, b) => a.properties.elevation - b.properties.elevation)
  .forEach((floor) => {
    console.log(
      `${floor.properties.details?.name}: ${floor.properties.elevation}m`
    );
  });

// Access geometry per floor
Object.entries(bundle.geometry).forEach(([floorId, geojson]) => {
  console.log(`${floorId}: ${geojson.features.length} features`);
});

The MVF bundle structure:

bundle.manifest     // Building metadata & coordinates
bundle.floors       // GeoJSON FeatureCollection of floor outlines
bundle.locations    // Named spaces (apartments, amenities)
bundle.connections  // Elevators, stairs, doors
bundle.geometry     // Per-floor geometry keyed by floor ID
bundle.kinds        // Feature type classifications
bundle.nodes        // Navigation graph

Why Use the @mappedin/mvf Library?

You could parse MVF manually with JSZip and JSON.parse, but the @mappedin/mvf library gives you:

Type Safety: Every property is typed. No more any or guessing field names. Your IDE autocompletes bundle.floors.features[0].properties.elevation.

Validation: The parser validates the MVF structure against the v3 schema. Malformed data throws errors before it causes bugs downstream.

Extension Support: MVF is modular. The library handles all standard extensions (locations, connections, navigation-flags, kinds, nodes) and lets you add custom ones.

Zero Boilerplate: One function call to go from ZIP buffer to fully parsed, typed bundle.

The Technical Beauty of MVF

What makes MVF special compared to simple floor plans?

Navigation-Ready: The connections extension maps every elevator, stairwell, and door. Combined with nodes, you can compute walking routes between any two points in the building.

Semantically Rich: The kinds extension classifies every geometry feature. That's how I know there are exactly 7,121 walls and 1,178 rooms. Each geometry ID maps to a type: wall, room, hallway, object, or poi.

Geographically Accurate: The building is anchored at real-world coordinates:

• Longitude: -118.232147
• Latitude: 34.040913

That's downtown Los Angeles, Arts District, for those following along on Google Maps.

Multi-Floor Aware: The floorStacks extension defines vertical relationships. This building has a single stack (common for towers), but the format supports multiple disconnected structures.

What This Means for Buyers

Traditional property searches give you:

• "36 floors"
• "Amenity-rich"
• "Premium finishes"

MVF analysis gives you:

• Exact unit count per floor
• Precise amenity inventory
• Walking distance to every elevator
• Which apartments share walls with trash rooms

If you're dropping seven figures on a condo, wouldn't you want to know that Unit 2708 is exactly 47 meters from the nearest elevator, but Unit 2701 is only 12 meters away?

Try It Yourself

Want to explore this building's data? I've built a Mappedin Demo Map Explorer where you can browse available venues, including this Multi-Family Hi-Rise Demo.

For the full MVF specification, check out the MVF v3 Documentation. It covers everything from coordinate systems to accessibility annotations.

Closing Thoughts

This exercise started as a quirky blog post idea and turned into a genuine appreciation for how much data exists in indoor mapping formats. A 4.71 MB ZIP file contains everything needed to navigate a 36-story building: every wall, door, elevator, and fire exit.

The Multi-Family Hi-Rise Demo is a Mappedin sample venue, not an actual building for sale. But the techniques here work on any MVF-formatted venue. Shopping malls, airports, hospitals, corporate campuses, all become queryable databases when you have the right format.

The future of real estate isn't just virtual tours. It's parsing the building data to answer questions that glossy marketing materials conveniently ignore.

This listing presented by a real estate agent who reads GeoJSON for fun.

---

Interested in indoor mapping? Check out my other posts on exploring the Mappedin SDK and indoor route optimization.