DEV Community

Cover image for I built the only wheelchair accessibility API (and an MCP server). Here's how it works.
Dave Sirota
Dave Sirota

Posted on

I built the only wheelchair accessibility API (and an MCP server). Here's how it works.

#api #mcp #webdev #datascience

Every restaurant app tells you the wait time, the Yelp rating, the Instagram vibe. None of them tell you if you can get through the front door in a wheelchair.

Google Maps has a "wheelchair accessible" boolean. That's it. Yes or no. No detail on what that means. No breakdown. No score. And it's frequently wrong.

I built ROLLIN to fix that. 56,000+ restaurants, bars, and venues across 6 US states, each scored 0-100 on real wheelchair accessibility. Not a binary label — a breakdown of six physical features that actually matter.

Today I want to walk through the technical side: the API, the MCP server, how search works, and how the data improves itself over time.

The Problem (for developers)

If you're building anything that touches physical locations — travel apps, restaurant discovery, navigation, corporate event planning, healthcare platforms — you have zero structured accessibility data to work with.

Google's Places API gives you wheelchair_accessible_entrance: true. That's one boolean for one feature. No scoring, no nuance, no confidence level, no breakdown of what "accessible" actually means.

There's nothing else. No public API for accessibility data. The 5.5 million wheelchair users in the US are invisible to every developer building location-based products.

The API

Base URL: https://joinrollin.com/api/v1

One request, real data:

curl "https://joinrollin.com/api/v1/locations?lat=40.7128&lng=-74.0060&radius=2&min_score=70" \
  -H "X-Api-Key: YOUR_KEY"
Enter fullscreen mode Exit fullscreen mode 
{
  "success": true,
  "count": 23,
  "next_cursor": null,
  "results": [
    {
      "name": "Blue Ribbon Sushi",
      "score": 87,
      "score_label": "Good",
      "features": {
        "wheelchair_entry": true,
        "accessible_restroom": true,
        "level_entry": true,
        "accessible_parking": false,
        "wide_aisles": true,
        "elevator": null
      },
      "distance_miles": 0.3,
      "verified": true
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

That's real data. Not mocked, not a demo. Live right now.

Six features, not a boolean

Every location is evaluated on six specific physical features:

Feature What it means
wheelchair_entry Can someone in a wheelchair enter the building?
accessible_restroom Is there a usable accessible restroom?
level_entry Is the entrance at grade (no steps)?
accessible_parking Are there accessible parking spots nearby?
wide_aisles Can a wheelchair navigate between tables?
elevator Multi-floor venue — is there an elevator?

Each feature is true, false, or null (unknown). The 0-100 score weights these by real-world impact — because a wheelchair-accessible entrance matters more than a parking spot.

Six endpoints

Endpoint Method What it does
/v1/locations GET Search by coordinates, radius, score, features, cuisine
/v1/locations/:id GET Full detail for one location
/v1/regions GET List all coverage areas with location counts
/v1/feedback POST Submit accessibility corrections (Developer+)
/v1/score/:id GET Detailed scoring breakdown (Business+)
/v1/health GET API status — no auth required

Pricing

Tier Rate Monthly Price
Free 10/min 1,000 calls $0
Developer 60/min 50,000 calls $29/mo
Business 200/min 500,000 calls $149/mo
Enterprise Custom Unlimited Custom

Free tier: no credit card, just your email. Get a key in 30 seconds at the Developer Portal.

The MCP Server

This is the part I'm most excited about.

Model Context Protocol lets AI assistants call external tools natively. We published an MCP server to npm so any MCP-compatible AI can search ROLLIN, look up locations, check coverage, and submit feedback — all through natural conversation.

Setup (60 seconds) 

npx -y rollin-mcp-server
Enter fullscreen mode Exit fullscreen mode

That's it. Works with:

  • Claude Desktop (Anthropic)
  • Claude Code (CLI)
  • Cursor (AI code editor)
  • VS Code (GitHub Copilot MCP)
  • Any MCP-compatible client

Claude Desktop config

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "rollin": {
      "command": "npx",
      "args": ["-y", "rollin-mcp-server"],
      "env": {
        "ROLLIN_API_KEY": "your_api_key_here"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Five tools

Tool What it does
search_locations "Find accessible Italian restaurants near me"
get_location_details "Tell me more about that sushi place"
list_regions "What cities do you cover?"
submit_feedback "That place has a ramp now"
check_health Verify API is up before making requests

What this looks like in practice

You: "Find me wheelchair accessible restaurants near Times Square with a score above 80."

Claude calls search_locations with lat=40.758, lng=-73.985, min_score=80 and responds:

Here are 3 highly accessible restaurants near Times Square:

  1. Junior's Restaurant (92) — Wheelchair entry, accessible restroom, level entry
  2. Sushi Nakazawa (85) — Wheelchair entry, level entry, wide aisles
  3. Carmine's Italian (82) — Wheelchair entry, accessible restroom, parking

You: "Does Carmine's have an elevator?"

Claude calls get_location_details and gives you the full breakdown.

No custom code. No API wrangling. Just conversation.

npm: npmjs.com/package/rollin-mcp-server
GitHub: github.com/DavidSirota/rollin-mcp-server

How Search Works

On the consumer side (joinrollin.com), ROLLIN has two search experiences:

Hero Search

The landing page has a search box that accepts natural language queries. Type "accessible sushi near Times Square" and it parses your intent — cuisine, location, accessibility priority — and returns scored results instantly.

You can also use filter chips: toggle specific features (wheelchair entry, accessible restroom, parking), set a minimum score, and narrow by region.

Map View

The full map experience renders all 56,000+ locations on an interactive map. Search as you pan, filter by score and features, and tap any marker for the full accessibility breakdown.

Both experiences hit the same data and scoring engine that powers the API. What developers get is the same data consumers see — no second-class data tier.

How the Data Gets Smarter

This is the real differentiator. ROLLIN's data isn't static. It improves every day through multiple feedback loops:

Community corrections

Users can submit corrections on any location. "That place added a ramp." "The restroom isn't actually accessible." Every correction is reviewed and weighted by the contributor's track record. Accurate contributors earn trust over time and their feedback carries more weight.

Continuous verification

Scores are recalculated as new data comes in. A location that gets verified by multiple sources — and where those sources agree — earns a higher confidence score. A location where data conflicts or is stale gets flagged.

Conservative by default

When critical data is missing, scores are held back. We'd rather tell you "we're not sure" than give you false confidence. A verified score is always worth more than one based on incomplete data.

The result

The more people use ROLLIN — searching, correcting, verifying — the better the data gets. That's not just a tagline. It's how the scoring engine is architected. Every interaction is a signal.

What You Can Build With This

Some ideas we're genuinely excited about:

  • Travel apps — add an accessibility layer to trip planning
  • Restaurant discovery — filter by "actually accessible," not just "ADA compliant"
  • Navigation apps — route wheelchair users to places they can actually enter
  • Corporate tools — help companies pick accessible venues for team events
  • Healthcare platforms — recommend accessible dining near hospitals and rehab centers
  • AI assistants — plug in the MCP server and give any AI real accessibility knowledge
  • Research — analyze accessibility patterns across cities and regions

Python SDK

On launch day, Stainless Commons auto-generated a Python SDK for the ROLLIN API — the same tooling behind the OpenAI and Stripe SDKs.

from rollin import Rollin

client = Rollin(api_key="your_key_here")
locations = client.locations.list(
    lat=40.7128, lng=-74.0060,
    radius=2, min_score=70
)

for loc in locations.results:
    print(f"{loc.name}: {loc.score}")
Enter fullscreen mode Exit fullscreen mode

Get Started

  1. Get a free API key: joinrollin.com/portal
  2. Read the docs: joinrollin.com/developers
  3. Set up MCP: joinrollin.com/mcp
  4. Browse the API overview: joinrollin.com/api
  5. Install the Python SDK: pip install git+https://github.com/stainless-commons/rollin-python.git

Free tier: 1,000 requests/month, no credit card. Enough to prototype anything.

Why I Built This

There are 5.5 million wheelchair users in the US. Most of them have learned not to trust "accessible" labels because the bar is embarrassingly low. A grab bar in a bathroom technically qualifies as "accessible." That doesn't help someone who can't get past the front step.

Nobody should have to call ahead to ask if they can get into a restaurant. That's the system we're fixing — one scored location at a time.

If you build something with the API or MCP server, I'd love to hear about it. Drop a comment or reach out — projects@stacklinestudio.com.

Links:

Top comments (0)