ChatGPT Actions (OpenAI Actions)

What ChatGPT can do with Park Graph

A ChatGPT custom GPT (or Team/Enterprise action) configured against Park Graph can do four user-visible things on behalf of a driver: search lots near a destination, start a paid parking session for a license plate, look up that session, and end it. Booking, lookup, and close are the createSession, getSession, and endSession REST operations that the custom GPT imports from the OpenAPI spec.

For lightweight, read-only discovery there is also a single dispatcher endpoint that bundles three actions (search_parking, check_availability, get_rates) behind one call. The Park Graph API enforces the same validation, scope, rate-limit, and audit-log rules that the dashboard sees, so an agent cannot do something a human operator cannot do.

Manifest (.well-known/ai-plugin.json)

Park Graph hosts the canonical plugin manifest at /.well-known/ai-plugin.json. Point a custom GPT at this URL during configuration and ChatGPT will discover the OpenAPI spec, auth scheme, and human-readable description automatically.

{
  "schema_version": "v1",
  "name_for_human": "Park Graph",
  "name_for_model": "park_graph",
  "description_for_human": "Find, hold, and pay for parking at any Park Graph–connected lot. QR-code receipts, real-time availability, dynamic pricing, no driver app required.",
  "description_for_model": "Park Graph is a parking infrastructure platform. Use the search action to find lots near a coordinate or address; the create_session action to start a paid session at a chosen lot for a license plate; the get_session action to look up status; and the end_session action to close a session and capture payment. Sessions are billed by the minute against the lot's hourly or daily rate. Dynamic pricing (event-based, occupancy-based, surge) may change the rate before a session starts but never after.",
  "auth": {
    "type": "user_http",
    "authorization_type": "bearer",
    "instructions": "End users issue an API key from https://parkgraph.com/dashboard/api-keys and paste it into the plugin configuration. Live keys start with pk_live_; sandbox keys start with pk_test_."
  },
  "api": {
    "type": "openapi",
    "url": "https://parkgraph.com/api/agents/openai/openapi.yaml",
    "is_user_authenticated": true
  },
  "logo_url": "https://parkgraph.com/logo.svg",
  "contact_email": "developers@parkgraph.com",
  "legal_info_url": "https://parkgraph.com/legal/terms"
}

Two ways ChatGPT calls Park Graph

A custom GPT configured from the OpenAPI spec gets four operations directly: searchParking (GET /api/v1/lots/search), createSession (POST /api/v1/sessions), getSession (GET /api/v1/sessions/{sessionId}), and endSession (POST /api/v1/sessions/end). These are the same REST endpoints documented in the API reference, so booking, lookup, and close all run through the standard v1 API.

Park Graph also exposes an optional single-endpoint dispatcher at POST /api/agents/openai/actions for read-only discovery. It accepts a JSON body with exactly one action from the closed set search_parking, check_availability, and get_rates, plus a parameters object whose shape depends on the action. The dispatcher requires the lots:read scope, is rate-limited to 60 requests/minute, and is gated to Pro and Enterprise plans (see below).

{
  "action": "search_parking",
  "parameters": {
    "lat": 39.6403,
    "lng": -106.3742,
    "radius_km": 5,
    "limit": 5
  }
}

The dispatcher is not part of the imported OpenAPI document — its closed action set is enforced server-side. Valid action values are exactly search_parking, check_availability, and get_rates; any other value is rejected. To create, look up, or end a session, call the REST operations above.

Bearer-token (OAuth-style) flow

ChatGPT supports two authentication patterns for custom GPT actions: end-user-supplied bearer tokens and full OAuth 2.0 with PKCE. Park Graph supports both. For most installs we recommend the bearer-token path because it lets each operator ship their own GPT to their team in minutes; reserve the full OAuth flow for ChatGPT Enterprise rollouts where individual end users authenticate with their corporate identity provider.

1. Step 1

   Operator opens https://parkgraph.com/dashboard/api-keys, names the key (e.g. 'ChatGPT custom GPT — sales team'), and clicks Create. Park Graph returns a one-time pk_live_… string.

2. Step 2

   Operator pastes the pk_live_ key into the plugin's auth field inside the GPT builder. ChatGPT stores the key encrypted and forwards it as Authorization: Bearer pk_live_… on every action call.

3. Step 3

   End users in the operator's workspace can now use the GPT without touching the API key. The dispatcher logs every call against the operator's audit log with action=, agent_platform=openai.

4. Step 4

   Rotation: operator clicks Rotate in /dashboard/api-keys, edits the GPT to use the new key, and the old key is revoked instantly.

Worked example: end-to-end conversation

The transcript below shows ChatGPT helping a driver park near Vail Village. Each → arrow is an action call generated by ChatGPT and dispatched to Park Graph.

# 1. Read-only discovery — dispatcher action (or the searchParking REST op)
→ POST /api/agents/openai/actions
   { "action": "search_parking",
     "parameters": { "lat": 39.6403, "lng": -106.3742, "radius_km": 1.5, "limit": 5 } }
   ← { "results": [
       { "id": "…", "name": "Vail Village Lifthouse Lot", "base_rate": 8.0 },
       { "id": "…", "name": "Lionshead Public Parking", "base_rate": 6.0 } ],
       "agent_platform": "openai" }

ChatGPT: 'I see two good options: Lifthouse Lot ($8/hr) and Lionshead
          Public ($6/hr). Which one?'

Driver: 'Lionshead. Plate is CO-7891.'

# 2. Booking is a write — the custom GPT calls the createSession REST operation
→ POST /api/v1/sessions
   { "lot_id": "…", "plate": "CO-7891" }
   ← { "session": { "id": "…", "session_code": "PG-VV7891",
                    "status": "active", "payment_intent_id": "pi_…",
                    "client_secret": "pi_…_secret_…" } }

ChatGPT: 'Done — session PG-VV7891 is active. Authorise the card on the
          receipt page; I will remind you before your 4 hours are up.'

# 3. Closing the session — the endSession REST operation (4 hours later)
→ POST /api/v1/sessions/end
   { "session_id": "…", "session_code": "PG-VV7891" }
   ← { "session": { "status": "completed",
                    "subtotal": 24.12, "owner_payout": 21.71 } }

Try it

The call below dispatches a read-only search_parking action (no session is created). Use it to confirm your bearer token before wiring up a custom GPT. Booking, lookup, and close go through the REST operations shown above.

curl -X POST https://parkgraph.com/api/agents/openai/actions \
  -H "Authorization: Bearer pk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "action": "search_parking",
    "parameters": { "lat": 39.6403, "lng": -106.3742, "radius_km": 5, "limit": 5 }
  }'

Configuring a custom GPT step-by-step

1. ChatGPT → Explore GPTs → My GPTs → Create.
2. Configure tab → Actions → Create new action.
3. Authentication → API Key → Bearer token. Paste pk_live_….
4. Schema → Import from URL → https://parkgraph.com/api/agents/openai/openapi.yaml
5. (Optional) Privacy policy URL → https://parkgraph.com/legal/privacy
6. Save → Test → ask the GPT 'find me parking near 39.6403, -106.3742'.

Plan gating & scopes

AI agent access is gated by plan. The dispatcher checks the operator's plan on every call and returns HTTP 403 with AI agent integrations require Pro or Enterprise plan for accounts on the free tier — this applies to every dispatcher action, including the read-only ones. Upgrade at /dashboard/billing.

Beyond the plan check, the bearer key must carry the right scopes: the dispatcher requires lots:read, and the booking REST operations ( createSession, endSession) require the session write scopes documented in the API reference. Every call is rate-limited (60 requests/minute on the dispatcher) and written to the operator's audit log with agent_platform=openai.

Related developer pages

• ChatGPT integration overview — broader context, conversation patterns, and prompt-engineering tips.
• API reference — the underlying REST endpoints that the dispatcher delegates to.
• MCP server (Claude) — the equivalent integration for Anthropic's Model Context Protocol.
• Microsoft Copilot plugin — the M365 plugin manifest that wraps the same dispatcher.
• ChatGPT parking booking landing page — public-facing page driving SERP traffic for "ChatGPT parking".
• Changelog — every API and dispatcher change since v1.0.