# DogPolicies (remote · dogpolicies.com)

Verified dog rules for California and Nevada travel: parks, beaches, hotels, fees, sourced and dated

- Trust score: 74/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `dogpolicies.com`: 74/100 (this document), [markdown](https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies.md), [page](https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies)
- npm · `dogpolicies-mcp`: 84/100, [markdown](https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies-mcp.md), [page](https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies-mcp)

## Channel facts

- Endpoint: `https://dogpolicies.com/mcp/`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.3.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 80/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 79/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7012 tokens (~152/item across 46 items; 15 tools + 31 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: schema churn in the 4 days we've observed: 13 tool removals, 0 breaking changes, 0 auth/transport breaks, 2 additions.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 15 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 17 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the DogPolicies MCP server?

DogPolicies is a hosted endpoint at https://dogpolicies.com/mcp/, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http xultrax-web-dogpolicies-mcp 'https://dogpolicies.com/mcp/'
```

### Cursor

```json
{
  "mcpServers": {
    "xultrax-web-dogpolicies-mcp": {
      "url": "https://dogpolicies.com/mcp/"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "xultrax-web-dogpolicies-mcp": {
      "type": "http",
      "url": "https://dogpolicies.com/mcp/"
    }
  }
}
```

### Codex

```toml
[mcp_servers.xultrax-web-dogpolicies-mcp]
url = "https://dogpolicies.com/mcp/"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xultrax-web-dogpolicies-mcp": {
      "type": "remote",
      "url": "https://dogpolicies.com/mcp/",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add xultrax-web-dogpolicies-mcp --url 'https://dogpolicies.com/mcp/' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  xultrax-web-dogpolicies-mcp:
    url: "https://dogpolicies.com/mcp/"
```

### Netclaw

```json
{
  "McpServers": {
    "xultrax-web-dogpolicies-mcp": {
      "Transport": "http",
      "Url": "https://dogpolicies.com/mcp/"
    }
  }
}
```

### Vellum

```bash
assistant mcp add xultrax-web-dogpolicies-mcp -t streamable-http -u 'https://dogpolicies.com/mcp/'
```

### Other

```json
{
  "mcpServers": {
    "xultrax-web-dogpolicies-mcp": {
      "type": "http",
      "url": "https://dogpolicies.com/mcp/"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 74, 0)

- [security] Resource “I-15” now points somewhere else: dogpolicies://route/i-15 → dogpolicies://route/i-15-nevada
- [security] Resource “US-50” now points somewhere else: dogpolicies://route/us-50 → dogpolicies://route/us-50-nevada
- [security] Resource “I-80” now points somewhere else: dogpolicies://route/i-80 → dogpolicies://route/i-80-nevada

### 2026-11-04 (score 74, −1)

- [security regression] Stability: 0.07 → fail
- [security regression] Tool “dogrulebook_get_brand_policy” was removed
- [security regression] Tool “dogrulebook_browse_answers” was removed
- [security regression] Tool “dogrulebook_changes_near” was removed
- [security regression] Tool “dogrulebook_changes_since” was removed
- [security regression] Tool “dogrulebook_compare_places” was removed
- [security regression] Tool “dogrulebook_find_hotels” was removed
- [security regression] Tool “dogrulebook_get_place” was removed
- [security regression] Tool “dogrulebook_get_rule” was removed
- [security regression] Tool “dogrulebook_near” was removed
- [security regression] Tool “dogrulebook_plan_trip” was removed
- [security regression] Tool “dogrulebook_report_correction” was removed
- [security regression] Tool “dogrulebook_route_stops” was removed
- [security regression] Tool “dogrulebook_search_places” was removed
- [security] Resource “US-50” now points somewhere else: dogpolicies://route/us-50 → dogpolicies://route/us-50-nevada
- [security] Resource “I-80” now points somewhere else: dogpolicies://route/i-80 → dogpolicies://route/i-80-nevada
- [security] Resource “I-15” now points somewhere else: dogpolicies://route/i-15 → dogpolicies://route/i-15-nevada
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “dogpolicies_changes_near” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_compare_places” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_find_hotels” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_get_place” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_near” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_plan_trip” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_report_correction” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_route_stops” rewrote its description, which is the text the model reads
- [security] Tool “dogpolicies_search_places” rewrote its description, which is the text the model reads
- [functional improvement] Schema quality: 174 → 152
- [functional improvement] Schema quality: 174 → 123
- [functional] Schema quality: excellent → good
- [functional] New prompt “drive_i5_with_dog”
- [functional] New resource “corridor-i5”
- [functional] Server version: 0.2.10 → 0.3.0
- [functional] Server version: 0.2.9 → 0.2.10
- [functional] New tool “dogpolicies_i5_conditions”
- [functional] New tool “dogpolicies_i5_corridor”
- [cosmetic] “dogpolicies_route_stops” added an optional parameter “ahead_miles”
- [cosmetic] “dogpolicies_route_stops” added an optional parameter “family”
- [cosmetic] “dogpolicies_route_stops” added an optional parameter “paired”

### 2026-11-03 (score 75, 0)

- [security] Resource “US-50” now points somewhere else: dogpolicies://route/us-50 → dogpolicies://route/us-50-nevada
- [security] Resource “I-80” now points somewhere else: dogpolicies://route/i-80 → dogpolicies://route/i-80-nevada
- [security] Resource “I-15” now points somewhere else: dogpolicies://route/i-15 → dogpolicies://route/i-15-nevada

### 2026-11-02 (score 75, +1)

- [security] Resource “US-50” now points somewhere else: dogpolicies://route/us-50 → dogpolicies://route/us-50-nevada
- [security] Resource “I-80” now points somewhere else: dogpolicies://route/i-80 → dogpolicies://route/i-80-nevada
- [security] Resource “I-15” now points somewhere else: dogpolicies://route/i-15 → dogpolicies://route/i-15-nevada
- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 0.2.8 → 0.2.9

### 2026-11-01 (score 74)

First indexed and scored.

## MCP tools (15)

### `dogpolicies_search_places` (~631 tokens)

Search places

Search parks, beaches, trails, hotels, campgrounds and cabin resorts in California and Nevada by name, location and dog rules.

Returns one page of places with a one-line answer ("Yes, on a leash no longer than 6 feet."), status (yes, yes_restricted, no, varies), verification date and page URL. Each result includes the place id.

Examples:
  \- "Off-leash beaches near San Diego" -> type="beach", off_leash=true, near={lat:32.72, lon:-117.16}
  \- "Can I bring my dog to Point Lobos?" -> query="Point Lobos"
  \- "State parks in Marin County that allow dogs" -> type="park", county="Marin", dogs_allowed=true
  \- "Lake Tahoe beaches in Nevada that allow dogs" -> type="beach", state="NV", dogs_allowed=true
  \- "Off-leash dog parks in Las Vegas" -> type="park", off_leash=true, county="Clark", state="NV"
  \- "RV parks in Fresno County that take dogs" -> type="campground", county="Fresno", dogs_allowed=true
  \- "Dog-friendly cabins in June Lake" -> type="cabins", query="June Lake", dogs_allowed=true
  \- "Restaurants with a dog-friendly patio in Alameda" -> type="restaurant", query="Alameda"

Input parameters:

- `area` (string): Area id, the name a traveler gives the trip: san-francisco, east-bay, peninsula, south-bay, north-bay, lake-tahoe, big-sur, mendocino-coast, yosemite, death-valley
- `county` (string): County name without "County", in California or Nevada, e.g. "Monterey" or "Washoe"
- `dogs_allowed` (boolean): true: only places that allow dogs somewhere; false: only places that do not
- `limit` (integer): Maximum results to return
- `near` (object): Limit to places near a point; results are sorted by distance
- `off_leash` (boolean): true: only places where the managing agency allows dogs off leash, at least at some times
- `offset` (integer): Results to skip, for pagination
- `query` (string): Words to match in the name, city, county or brand
- `region` (string): Region id, e.g. central-coast, san-diego or reno-tahoe-nevada
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `state` (string): "CA" or "NV". Also tells apart counties with the same name, such as Humboldt.
- `type` (string): Kind of place; campground covers campgrounds and RV parks (some also rent cabins), cabins covers cabin resorts with no campground, restaurant covers restaurants, cafes, bars, breweries and tasting ro…

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `count` (number)
- `has_more` (boolean)
- `license` (object)
- `offset` (number)
- `places` (array)
- `total` (number)

### `dogpolicies_near` (~345 tokens)

What is near a town

Anything for dogs around a town, county or point: everything dog-related nearby, grouped by kind: beaches, parks, trails, hotels, campgrounds, cabins, places to eat and rest areas, each sorted by distance, with the dog rule and citation for each. Answers "what can I do with my dog there?" for a named place.

Takes a town or county name (no coordinates needed) or a point.

Examples:
  \- "What can my dog do in Carmel?" -> place="Carmel"
  \- "Dog beaches and parks around South Lake Tahoe" -> place="South Lake Tahoe", types=["beach","park"]
  \- "Anything dog-friendly within 5 miles of here" -> near={lat:36.6, lon:-121.9}, radius_miles=5

Input parameters:

- `dogs_allowed_only` (boolean): Leave out places where dogs are not allowed
- `near` (object): A point instead of a town; give one of place or near
- `per_type` (integer): Nearest results to show per kind
- `place` (string): A city, county or area in California or Nevada, e.g. "Monterey", "South Lake Tahoe", "Washoe County, NV", "Las Vegas", "East Bay" or "Lake Tahoe"
- `radius_miles` (number): Search radius in miles around the town or point (an area is its own boundary; the radius is ignored)
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `types` (array): Kinds to include; all by default

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `center` (object)
- `groups` (array)
- `label` (string)
- `license` (object)
- `radius_miles` (number)
- `total` (number)

### `dogpolicies_get_place` (~202 tokens)

Get place details

The full record for one place you already know by id: every dog rule with its display text, the rules list, and each source with its URL, publisher, capture date and quote. A place on I-5 in California also carries its axis position (s meters from San Ysidro on the I-5 centerline, Caltrans mile, meters off the road, side of northbound travel, road elevation, strip) and, when it is the dog side of a paired stop, that pair: the exit and the people-stops near it (counted from OpenStreetMap, never named, not verified for restrooms).

Takes a place id, as returned in every search result. Example: id="carmel-beach".

Input parameters:

- `id` (string, required): Place id, e.g. "fort-funston"
- `response_format` (string): 'markdown' for readable text, 'json' for structured data

Output parameters:

- `answer` (string)
- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `axis`: Where the place sits on the I-5 axis: s meters from San Ysidro, Caltrans mile, meters off the road, side of northbound travel, road elevation, strip; null off I-5
- `citation` (string): Copy-ready citation: answer, source, date checked, record URL, license
- `confidence` (string): stated: the place's own source says it; inferred_from_agency: an agency-wide rule; inherited_brand: the chain's policy, not confirmed by this hotel
- `confirmed_by`
- `facts` (array)
- `freshness` (string): fresh: inside its review interval; due: past it; stale: past twice it, confirm before you go; unreadable: the last check could not read the source
- `id` (string)
- `license` (object)
- `name` (string)
- `not_stated` (array): Expected facts the sources do not state; never guess these
- `paired_stop`
- `record_license` (string)
- `review_due` (string)
- `rule_records` (array)
- `rules` (array)
- `source_urls` (array)
- `sources` (array)
- `status` (string)
- `type` (string)
- `uid` (string): Stable id that survives a rename
- `url` (string)
- `verified_at` (string)

### `dogpolicies_compare_places` (~150 tokens)

Compare places side by side

Which one is better for a dog? Compare two to six places on the facts that decide a dog trip: dogs allowed, leash rule, where dogs may go, pet fee, weight limit, pets per room, restrictions, plus confidence, freshness and who confirmed each record. One row per fact, one column per place, every place with its citation.

Answers "which one?" between candidates; ids come from any search result. Example: ids=["carmel-beach","asilomar-state-beach"].

Input parameters:

- `ids` (array, required): Two to six place ids from search results
- `response_format` (string): 'markdown' for readable text, 'json' for structured data

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `license` (object)
- `places` (array)
- `rows` (array)

### `dogpolicies_plan_trip` (~550 tokens)

Plan a trip with a dog

Plan a stay in a California or Nevada town with a dog, in one call: where to stay (hotels, campgrounds and cabins that will take this dog, with the pet fee for the whole stay worked out), what to do (beaches, parks and trails that allow dogs, nearest first) and where to eat (patios that take dogs), every item with its citation. When the town is within 10 miles of I-5 in California, the result also carries the drive leg on the I-5 axis: the town's position (Caltrans mile and s meters from San Ysidro), the next family stops (restrooms and a pet area or dog park stated by their official source) in each direction within 60 miles, and the paired stops (an exit with people-stops nearby, counted from OpenStreetMap and never named, matched to the nearest dog-legal place) within 10 miles.

Inputs: the town or county and the dog: weight, how many dogs, nights, and the most the user will pay in pet fees.

Examples:
  \- "Three nights in Monterey with our 70 lb Lab, pet fees under $100" -> place="Monterey", dog_weight_lb=70, nights=3, max_total_fee=100
  \- "A weekend in South Lake Tahoe with two small dogs" -> place="South Lake Tahoe", dogs=2, nights=2
  \- "Camping near Mammoth Lakes with a dog" -> place="Mono County", stay_types=["campground","cabins"]

Input parameters:

- `dog_weight_lb` (number): The dog's weight in pounds
- `dogs` (integer): Number of dogs
- `include_possible` (boolean): Include stays that need a call to confirm
- `max_total_fee` (number): Most the guest will pay in pet fees for the whole stay, USD
- `near` (object): A point instead of a town; give one of place or near
- `nights` (integer): Nights of the stay
- `per_section` (integer): Results per section
- `place` (string): A city, county or area in California or Nevada, e.g. "Monterey", "South Lake Tahoe", "Washoe County, NV", "Las Vegas", "East Bay" or "Lake Tahoe"
- `radius_miles` (number): Search radius in miles around the town or point (an area is its own boundary; the radius is ignored)
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `stay_types` (array): Kinds of stay to consider

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `asked` (object)
- `attribution_text` (string)
- `attribution_url` (string)
- `i5`: When the town is within 10 miles of I-5 in California: the trip's position on the I-5 axis, the next family stops in each direction within 60 miles, and the paired stops within 10 miles
- `label` (string)
- `license` (object)
- `outings` (array)
- `radius_miles` (number)
- `stay_counts` (object)
- `stays` (array)

### `dogpolicies_find_hotels` (~575 tokens)

Find hotels for a dog

Find hotels and motels in California and Nevada that will take a specific dog, with the estimated pet fee for the stay.

Every amount is the hotel's pet fee, never the room rate: DogPolicies has no room prices.

Each hotel is sorted into "match" (the policy says yes on everything asked), "possible" (nothing rules it out, but something needs a call: a hotel that decides case by case, an unstated weight limit, a limit the hotel lifts with its approval, an "up to" fee) or excluded (left out). Matches come first, cheapest pet fee first. The fee arithmetic is spelled out for every result.

Examples:
  \- "Will a Monterey hotel take my 70 lb Lab for under $50?" -> county="Monterey", dog_weight_lb=70, max_total_fee=50
  \- "Two dogs, three nights near Palm Springs" -> near={lat:33.83, lon:-116.55}, dogs=2, nights=3
  \- "Is the Motel 6 in Fresno dog friendly?" -> query="Motel 6 Fresno"
  \- "A Las Vegas hotel for my 60 lb dog" -> county="Clark", state="NV", dog_weight_lb=60

Input parameters:

- `area` (string): Area id, the name a traveler gives the trip: san-francisco, east-bay, peninsula, south-bay, north-bay, lake-tahoe, big-sur, mendocino-coast, yosemite, death-valley
- `brand` (string): Only this hotel brand
- `county` (string): County name without "County", in California or Nevada, e.g. "Monterey" or "Washoe"
- `dog_weight_lb` (number): The dog's weight in pounds
- `dogs` (integer): Number of dogs
- `include_possible` (boolean): Include hotels that need a call to confirm
- `limit` (integer): Maximum results to return
- `max_total_fee` (number): Most the guest will pay in pet fees for the whole stay, USD
- `near` (object): Limit to places near a point; results are sorted by distance
- `nights` (integer): Nights of the stay
- `offset` (integer): Results to skip, for pagination
- `query` (string): Words in the hotel name, city or brand
- `region` (string): Region id, e.g. central-coast, san-diego or reno-tahoe-nevada
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `state` (string): "CA" or "NV". Also tells apart counties with the same name, such as Humboldt.

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `count` (number)
- `counts` (object)
- `has_more` (boolean)
- `hotels` (array)
- `license` (object)
- `offset` (number)
- `total` (number)

### `dogpolicies_get_brand_policy` (~142 tokens)

Get hotel brand pet policy

A hotel chain's published pet policy: pets per room, weight limit, fee, rules, listed exceptions and how many California and Nevada properties carry it.

Brands covered: Best Western (best-western), Extended Stay America (extended-stay-america), Kimpton Hotels (kimpton), La Quinta by Wyndham (la-quinta), Motel 6 (motel-6), Red Roof Inn (red-roof). Example: brand="red-roof" or brand="Kimpton".

Input parameters:

- `brand` (string, required): Brand id or name
- `response_format` (string): 'markdown' for readable text, 'json' for structured data

Output parameters:

- `answer` (string)
- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `facts` (array)
- `id` (string)
- `license` (object)
- `name` (string)
- `not_stated` (array): Expected facts the sources do not state; never guess these
- `source_urls` (array)
- `url` (string)
- `verified_at` (string)

### `dogpolicies_browse_answers` (~153 tokens)

Browse answered questions

Ready-made lists that answer common questions (list the state parks, national parks, beaches or hotels that allow dogs), such as "Which California national parks allow dogs?" or "Where can dogs go off leash on California beaches?".

Without a slug, lists every question with its slug and result count. With a slug, returns that question's places.

Input parameters:

- `limit` (integer): Maximum results to return
- `offset` (integer): Results to skip, for pagination
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `slug` (string): Question slug from the list, e.g. "off-leash-dog-beaches-california"

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `license` (object)
- `places` (array)
- `questions` (array)
- `total` (number)

### `dogpolicies_route_stops` (~1326 tokens)

Dog stops along a highway

Dog-friendly stops along a California or Nevada highway, in driving order: rest areas (Caltrans rest areas with pet areas; Nevada rest areas, where leashed dogs are allowed), travel stops with dog parks, hotels, cabin resorts and campgrounds or RV parks near the road (all checked against the dog's weight and the pet-fee budget) and parks or beaches that allow dogs.

Each stop has its mile on the route and its distance off the road. Each route covers one state and stops at the state line. California miles follow the Caltrans odometer: north on I-5 (from the Mexican border), US-101 (from Los Angeles), Highway 1 (from Dana Point) and I-15 (i-15, San Diego to Primm); east on I-80 (i-80, San Francisco to the Nevada line) and US-50 (us-50, West Sacramento to Stateline). Nevada routes count Nevada mileposts from the California line, matching the exit numbers: north on I-15 (i-15-nevada), east on I-80 (i-80-nevada) and US-50 (us-50-nevada, Stateline to Utah); north on US-95 (us-95-nevada, California line to Oregon) and US-93 (us-93-nevada, Hoover Dam to Idaho), whose miles include the stretches they share with other highways. Where Highway 1 runs on US-101, stops on that stretch say so in on_road. A starting point is set with from_mile or near, plus a direction; ahead_miles limits the window to that many miles from the start in the direction of travel.

On I-5 in California each stop also carries its position on the I-5 centerline in meters from San Ysidro (s_m), miles_ahead of the start along the direction of travel, the side of the road it serves (right or left of northbound travel, or both), its distance off the freeway, the road's elevation in meters and the stretch (strip) it is in, plus restrooms, water, pet_area, dog_park and hours as its official source states them. With family=true only stops whose official source states restrooms and a pet area or dog park are returned. With paired=true the result also lists paired stops: a freeway exit in the window with places…

Input parameters:

- `ahead_miles` (number): Window in miles from the start (near or from_mile) in the direction of travel; an alternative to to_mile
- `direction` (string): Direction of travel. Route miles increase going north, or east on I-80 and US-50; north and east both mean increasing miles
- `dog_friendly_only` (boolean): Leave out stops where dogs are not allowed
- `dog_weight_lb` (number): The dog's weight in pounds
- `dogs` (integer): Number of dogs
- `family` (boolean): Only stops whose official source states restrooms and a pet area or dog park (I-5 in California)
- `from_mile` (number): Start at this route mile
- `kinds` (array): Kinds of stops to include; all by default
- `limit` (integer): Maximum results to return
- `max_total_fee` (number): Most the guest will pay in pet fees for the whole stay, USD
- `near` (object): Start from the route mile nearest this point
- `nights` (integer): Nights of the stay
- `offset` (integer): Results to skip, for pagination
- `paired` (boolean): Also list the paired stops in the window: an exit with people-stops nearby and the nearest dog-legal place (I-5 in California)
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `route` (string): Route id
- `to_mile` (number): Stop at this route mile

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `count` (number)
- `guide` (string)
- `has_more` (boolean)
- `license` (object)
- `offset` (number)
- `paired_stops` (array)
- `route` (string)
- `start` (object)
- `stops` (array)
- `total` (number)

### `dogpolicies_i5_corridor` (~747 tokens)

I-5 corridor by stretch

The I-5 corridor in California as eleven named stretches (strips) on the I-5 centerline, from San Ysidro (s = 0 m) to the Oregon line (s ≈ 1,281,400 m), and the dog stops in any stretch, mile range or window ahead of a point. Every stop carries its s in meters from San Ysidro, its Caltrans odometer mile, the side of the road it serves (right or left of northbound travel, or both), its distance off the freeway, the road's elevation, and restrooms, water, pet area, dog park and hours as its official source states them. A family stop is one whose official source states restrooms and a pet area or dog park. A paired stop is a freeway exit with places to stop for people nearby (located through OpenStreetMap, counted by kind, never named and not verified for restrooms) matched to the nearest DogPolicies place that allows dogs within about a mile, with its rule and source.

With no stretch, miles or point, the result is the list of stretches with their s and mile ranges and stop counts. Strips: sandiego (San Ysidro → Camp Pendleton), orange-la (Camp Pendleton → East LA), grapevine (East LA → Wheeler Ridge), kern-westside (Wheeler Ridge → Kettleman), westside (Kettleman → Santa Nella), delta (Santa Nella → Stockton), sacramento (Stockton → Woodland), valley (Woodland → Williams), tehama (Williams → Red Bluff), shasta (Red Bluff → Mt Shasta), siskiyou (Mt Shasta → Siskiyou Summit).

Examples:
  \- "What is between the Grapevine and Kettleman?" -> strip="grapevine" (East LA to Wheeler Ridge) and strip="kern-westside" (Wheeler Ridge to Kettleman)
  \- "The next 5 family stops northbound from Stockton" -> near={lat:37.95, lon:-121.29}, direction="north", family=true, limit=5
  \- "Every stop between mile 300 and 340" -> from_mile=300, to_mile=340
  \- "Exits with somewhere for people and a park for the dog in the Sacramento stretch" -> strip="sacramento", paired=true

Input parameters:

- `ahead_miles` (number): Window in miles from near in the direction of travel
- `direction` (string): Direction of travel from near; north means increasing s
- `dog_friendly_only` (boolean): Leave out stops where dogs are not allowed
- `family` (boolean): Only family stops
- `from_mile` (number): Start of a mile range (Caltrans odometer)
- `kinds` (array): Kinds of stops to include; all by default
- `limit` (integer): Maximum stops to return
- `near` (object): A point on or near I-5; the window starts at the nearest point of the road
- `offset` (integer): Stops to skip
- `paired` (boolean): Also list the paired stops in the window
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `strip` (string): A stretch by id (sandiego, orange-la, grapevine, kern-westside, westside, delta, sacramento, valley, tehama, shasta, siskiyou)
- `to_mile` (number): End of a mile range

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `axis_version` (string)
- `license` (object)
- `paired_stops` (array)
- `stops` (array)
- `strips` (array)
- `total` (number)
- `window`

### `dogpolicies_i5_conditions` (~331 tokens)

I-5 conditions now

Current Caltrans lane closures, road-weather station readings, changeable-message-sign text and chain-control status on I-5 in California, each placed on the I-5 centerline (s meters from San Ysidro and the Caltrans mile) and matched to the nearest DogPolicies dog stop. Conditions come from Caltrans' CWWP2 feeds fetched within the last 15 minutes (fetched_at in the result) and are not verified rules.

The window is a mile range (from_mile, to_mile) or a point with a direction and ahead_miles; with none, the whole of I-5 in California. Needs the network (the document is read from dogpolicies.com); offline the result is an error with code offline.

Examples:
  \- "Is there a closure or chains on the Grapevine right now?" -> from_mile=170, to_mile=222
  \- "Weather and closures in the next 60 miles northbound from Redding" -> near={lat:40.59, lon:-122.39}, direction="north", ahead_miles=60

Input parameters:

- `ahead_miles` (number): Window in miles from near
- `direction` (string): Direction of travel from near
- `from_mile` (number): Start of a mile range
- `near` (object): A point on or near I-5
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `to_mile` (number): End of a mile range

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `chain_controls` (array)
- `chains_in_effect` (boolean)
- `closures` (array)
- `fetched_at` (string)
- `license` (object)
- `notice` (string)
- `signs` (array)
- `source` (object)
- `weather` (array)
- `window`

### `dogpolicies_get_rule` (~135 tokens)

Get one rule by id

One rule (a fee, a leash rule, a weight limit) by its stable id, with its value, the source it cites, the quote, its confidence, the date it was verified and its freshness, plus the place's citation line. Rule ids look like "rul_<place uid>_<kind>" and appear in every place result as rule_records.

Input parameters:

- `id` (string, required): Rule id, e.g. "rul_t6cqwy0x4ce2dmpq_fee"
- `response_format` (string): 'markdown' for readable text, 'json' for structured data

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `license` (object)
- `place` (object)
- `rule` (object)

### `dogpolicies_changes_since` (~144 tokens)

Changes since a date

Everything that changed in the whole data set since a date: verification events and rule changes everywhere, newest first, so an agent can poll cheaply instead of re-reading every record. Each entry names the place, what happened (confirmed, changed, source_gone, blocked, disputed), who checked, and links the record.

Input parameters:

- `limit` (integer): Maximum results to return
- `offset` (integer): Results to skip, for pagination
- `outcome` (string): Only events with this outcome
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `since` (string, required): Date, YYYY-MM-DD

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `count` (number)
- `events` (array)
- `has_more` (boolean)
- `license` (object)
- `rule_changes` (array)
- `total` (number)

### `dogpolicies_changes_near` (~263 tokens)

What changed near a town

Verification events (confirmed, changed, source gone, blocked, disputed) since a date for places within a radius of a town, county or point, newest first. The way to answer "has anything changed around Tahoe since my last trip?" or to re-check a saved itinerary.

Example: "What changed near Monterey since September?" -> place="Monterey", since="2026-09-01"

Input parameters:

- `limit` (integer): Maximum results to return
- `near` (object): A point instead of a town; give one of place or near
- `offset` (integer): Results to skip, for pagination
- `outcome` (string): Only events with this outcome
- `place` (string): A city, county or area in California or Nevada, e.g. "Monterey", "South Lake Tahoe", "Washoe County, NV", "Las Vegas", "East Bay" or "Lake Tahoe"
- `radius_miles` (number): Search radius in miles around the town or point (an area is its own boundary; the radius is ignored)
- `response_format` (string): 'markdown' for readable text, 'json' for structured data
- `since` (string, required): Date, YYYY-MM-DD

Output parameters:

- `as_of` (string): Date the data was built (YYYY-MM-DD)
- `attribution_text` (string)
- `attribution_url` (string)
- `count` (number)
- `events` (array)
- `has_more` (boolean)
- `label` (string)
- `license` (object)
- `radius_miles` (number)
- `total` (number)

### `dogpolicies_report_correction` (~183 tokens)

Report a correction

File a correction when a user says a rule on a record is wrong or has changed (a fee went up, a beach closed to dogs, a hotel now takes two pets). The report goes to a person who re-reads the official source; nothing is published automatically and the record does not change until it is verified. Takes the place id, a sentence or two on what is wrong, and optionally the official page the user saw. The only personal detail it accepts is an optional contact the user offers.

Input parameters:

- `contact` (string): How to reach the reporter, only if they offer it
- `message` (string, required): What is wrong, in the user's words
- `place_id` (string, required): Place id from a search result
- `source_url` (string): The official page that shows the current rule, if the user has it

Output parameters:

- `place_id` (string)
- `report_id` (string|null)
- `status` (string)
- `url` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies#diagnostics

## Score history

- 2026-11-05: 74
- 2026-11-04: 74
- 2026-11-03: 75
- 2026-11-02: 75
- 2026-11-01: 74

## Common questions

### What is the DogPolicies MCP server?

DogPolicies is an MCP server listed in the public MCP registry as io.github.xultrax-web/dogpolicies-mcp. Verified dog rules for California and Nevada travel: parks, beaches, hotels, fees, sourced and dated. This page covers its hosted endpoint (https://dogpolicies.com/mcp/).

### Is the DogPolicies MCP server safe to use?

DogPolicies scores 74 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the DogPolicies MCP server expose?

DogPolicies exposes 15 tools: dogpolicies_search_places, dogpolicies_near, dogpolicies_get_place, dogpolicies_compare_places, dogpolicies_plan_trip, and 10 more. Their descriptions and schemas cost roughly 5,877 tokens of context every time the server is loaded.

### Does the DogPolicies MCP server require authentication?

No. We connected to DogPolicies without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the DogPolicies MCP server still maintained?

DogPolicies is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://dogpolicies.com/mcp/
- Repository: https://github.com/xultrax-web/dogpolicies-mcp
- Website: https://dogpolicies.com/mcp/about/
- Changelog RSS feed: https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies.xml
- Changelog JSON feed: https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies.json
- HTML version of this page: https://verifymcp.io/servers/xultrax-web-dogpolicies-mcp/dogpolicies