diff --git a/crates/modelrelay-cloud/src/routes/auth.rs b/crates/modelrelay-cloud/src/routes/auth.rs
index a63377b..9057f90 100644
--- a/crates/modelrelay-cloud/src/routes/auth.rs
+++ b/crates/modelrelay-cloud/src/routes/auth.rs
@@ -27,7 +27,10 @@ fn client_ip(headers: &HeaderMap) -> IpAddr {
 }
 
 /// Render a 429 Too Many Requests page.
-fn rate_limit_response() -> Response {
+///
+/// `path` is the canonical URL path of the request that triggered the rate limit
+/// (e.g. `/signup` or `/login`), used for per-page og:url and canonical.
+fn rate_limit_response(path: &str) -> Response {
     let body = "\
 <div class=\"card\" style=\"border-left: 3px solid #fbbf24;\">\
   <h2 style=\"display:flex;align-items:center;gap:10px;\">\
@@ -38,7 +41,7 @@ fn rate_limit_response() -> Response {
   <p style=\"margin-top:12px;color:#8b949e;font-size:0.9rem;\">This limit protects your account from unauthorized access attempts.</p>\
   <a href=\"/\" class=\"btn\" style=\"margin-top:20px;\">Back to Home</a>\
 </div>";
-    let html = modelrelay_web::templates::page_shell("Too Many Requests", body, false);
+    let html = modelrelay_web::templates::page_shell("Too Many Requests", path, body, false);
     (StatusCode::TOO_MANY_REQUESTS, Html(html)).into_response()
 }
 
@@ -67,6 +70,7 @@ pub async fn signup_page(session: Session) -> Response {
     let csrf_field = csrf::hidden_field(&session).await;
     Html(modelrelay_web::templates::page_shell(
         "Sign Up",
+        "/signup",
         &signup_form_html(None, &csrf_field),
         false,
     ))
@@ -83,7 +87,7 @@ pub async fn signup_submit(
 ) -> Response {
     let ip = client_ip(&headers);
     if state.rate_limiter.is_limited(ip) {
-        return rate_limit_response();
+        return rate_limit_response("/signup");
     }
 
     let csrf_field = csrf::hidden_field(&session).await;
@@ -91,6 +95,7 @@ pub async fn signup_submit(
     let Some(ref pool) = state.db else {
         return Html(modelrelay_web::templates::page_shell(
             "Sign Up",
+            "/signup",
             "<div class=\"card\"><h2>Error</h2><p>Database not available.</p></div>",
             false,
         ))
@@ -104,6 +109,7 @@ pub async fn signup_submit(
     if email.is_empty() || !email.contains('@') {
         return Html(modelrelay_web::templates::page_shell(
             "Sign Up",
+            "/signup",
             &signup_form_html(Some("Please enter a valid email address."), &csrf_field),
             false,
         ))
@@ -112,6 +118,7 @@ pub async fn signup_submit(
     if password.len() < 8 {
         return Html(modelrelay_web::templates::page_shell(
             "Sign Up",
+            "/signup",
             &signup_form_html(Some("Password must be at least 8 characters."), &csrf_field),
             false,
         ))
@@ -130,6 +137,7 @@ pub async fn signup_submit(
         state.rate_limiter.record_attempt(ip);
         return Html(modelrelay_web::templates::page_shell(
             "Sign Up",
+            "/signup",
             &signup_form_html(
                 Some("An account with this email already exists. <a href=\"/login\">Log in instead</a>."),
                 &csrf_field,
@@ -146,6 +154,7 @@ pub async fn signup_submit(
             tracing::error!("password hash error: {e}");
             return Html(modelrelay_web::templates::page_shell(
                 "Sign Up",
+                "/signup",
                 &signup_form_html(Some("Internal error. Please try again."), &csrf_field),
                 false,
             ))
@@ -171,6 +180,7 @@ pub async fn signup_submit(
             tracing::error!("user insert error: {e}");
             return Html(modelrelay_web::templates::page_shell(
                 "Sign Up",
+                "/signup",
                 &signup_form_html(
                     Some("Could not create account. Please try again."),
                     &csrf_field,
@@ -210,6 +220,7 @@ pub async fn login_page(session: Session) -> Response {
     let csrf_field = csrf::hidden_field(&session).await;
     Html(modelrelay_web::templates::page_shell(
         "Log In",
+        "/login",
         &login_form_html(None, &csrf_field),
         false,
     ))
@@ -225,7 +236,7 @@ pub async fn login_submit(
 ) -> Response {
     let ip = client_ip(&headers);
     if state.rate_limiter.is_limited(ip) {
-        return rate_limit_response();
+        return rate_limit_response("/login");
     }
 
     let csrf_field = csrf::hidden_field(&session).await;
@@ -233,6 +244,7 @@ pub async fn login_submit(
     let Some(ref pool) = state.db else {
         return Html(modelrelay_web::templates::page_shell(
             "Log In",
+            "/login",
             "<div class=\"card\"><h2>Error</h2><p>Database not available.</p></div>",
             false,
         ))
@@ -252,6 +264,7 @@ pub async fn login_submit(
         state.rate_limiter.record_attempt(ip);
         return Html(modelrelay_web::templates::page_shell(
             "Log In",
+            "/login",
             &login_form_html(Some("Invalid email or password."), &csrf_field),
             false,
         ))
@@ -262,6 +275,7 @@ pub async fn login_submit(
         state.rate_limiter.record_attempt(ip);
         return Html(modelrelay_web::templates::page_shell(
             "Log In",
+            "/login",
             &login_form_html(Some("Invalid email or password."), &csrf_field),
             false,
         ))
diff --git a/crates/modelrelay-cloud/src/routes/checkout.rs b/crates/modelrelay-cloud/src/routes/checkout.rs
index b61e8ca..e9e7c10 100644
--- a/crates/modelrelay-cloud/src/routes/checkout.rs
+++ b/crates/modelrelay-cloud/src/routes/checkout.rs
@@ -11,11 +11,21 @@ static CANCEL_HTML: &str = include_str!("../../templates/checkout_cancel.html");
 static SUCCESS_HTML: &str = include_str!("../../templates/checkout_success.html");
 
 fn success_page() -> String {
-    modelrelay_web::templates::page_shell("Subscription Active", SUCCESS_HTML, true)
+    modelrelay_web::templates::page_shell(
+        "Subscription Active",
+        "/checkout/success",
+        SUCCESS_HTML,
+        true,
+    )
 }
 
 fn cancel_page() -> String {
-    modelrelay_web::templates::page_shell("Checkout Cancelled", CANCEL_HTML, false)
+    modelrelay_web::templates::page_shell(
+        "Checkout Cancelled",
+        "/checkout/cancel",
+        CANCEL_HTML,
+        false,
+    )
 }
 
 /// POST /checkout — create a Stripe Checkout Session and redirect to Stripe.
@@ -26,6 +36,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
     let Some(ref key) = state.stripe_key else {
         return Html(modelrelay_web::templates::page_shell(
             "Billing Not Configured",
+            "/checkout",
             "<div class=\"card\" style=\"border-left: 3px solid #fbbf24;\">\
              <h2 style=\"display:flex;align-items:center;gap:10px;\">\
              <svg width=\"22\" height=\"22\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"#fbbf24\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\">\
@@ -42,6 +53,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
     if price_id.is_empty() {
         return Html(modelrelay_web::templates::page_shell(
             "Billing Not Configured",
+            "/checkout",
             "<div class=\"card\" style=\"border-left: 3px solid #fbbf24;\">\
              <h2 style=\"display:flex;align-items:center;gap:10px;\">\
              <svg width=\"22\" height=\"22\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"#fbbf24\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\">\
@@ -104,6 +116,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
                 } else {
                     Html(modelrelay_web::templates::page_shell(
                         "Checkout Error",
+                        "/checkout",
                         "<p>Stripe did not return a checkout URL.</p>\
                          <p class=\"back-link\"><a href=\"/pricing\">&larr; Back to pricing</a></p>",
                         false,
@@ -115,6 +128,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
                 tracing::error!("stripe response parse error: {e}");
                 Html(modelrelay_web::templates::page_shell(
                     "Checkout Error",
+                    "/checkout",
                     "<p>Could not process Stripe response.</p>\
                      <p class=\"back-link\"><a href=\"/pricing\">&larr; Back to pricing</a></p>",
                     false,
@@ -128,6 +142,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
             tracing::error!("stripe API error: {status} — {body}");
             Html(modelrelay_web::templates::page_shell(
                 "Checkout Error",
+                "/checkout",
                 "<p>Could not create checkout session. Please try again later.</p>\
                  <p class=\"back-link\"><a href=\"/pricing\">&larr; Back to pricing</a></p>",
                 false,
@@ -138,6 +153,7 @@ pub async fn create(session: Session, State(state): State<Arc<CloudState>>) -> R
             tracing::error!("stripe request error: {e}");
             Html(modelrelay_web::templates::page_shell(
                 "Checkout Error",
+                "/checkout",
                 "<p>Could not reach payment provider. Please try again later.</p>\
                  <p class=\"back-link\"><a href=\"/pricing\">&larr; Back to pricing</a></p>",
                 false,
diff --git a/crates/modelrelay-cloud/src/routes/dashboard.rs b/crates/modelrelay-cloud/src/routes/dashboard.rs
index cd57c1e..2962435 100644
--- a/crates/modelrelay-cloud/src/routes/dashboard.rs
+++ b/crates/modelrelay-cloud/src/routes/dashboard.rs
@@ -56,10 +56,12 @@ struct ApiKeyRow {
 // ─── GET /dashboard ─────────────────────────────────────────────────────────
 
 /// GET /dashboard — show subscription status and API key info.
+#[allow(clippy::too_many_lines)]
 pub async fn page(session: Session, State(state): State<Arc<CloudState>>) -> Response {
     let Some(ref pool) = state.db else {
         return Html(modelrelay_web::templates::page_shell(
             "Dashboard",
+            "/dashboard",
             &no_db_html(),
             true,
         ))
@@ -88,6 +90,7 @@ pub async fn page(session: Session, State(state): State<Arc<CloudState>>) -> Res
             tracing::error!("dashboard user query error: {e}");
             return Html(modelrelay_web::templates::page_shell(
                 "Dashboard",
+                "/dashboard",
                 "<div class=\"card\"><h2>Error</h2><p>Could not load your account. Please try again later.</p></div>",
                 true,
             ))
@@ -109,6 +112,7 @@ pub async fn page(session: Session, State(state): State<Arc<CloudState>>) -> Res
         let html = admin_dashboard_html(&user.email, &keys, &csrf_field);
         Html(modelrelay_web::templates::page_shell_custom(
             "Dashboard",
+            "/dashboard",
             &html,
             true,
             "",
@@ -158,6 +162,7 @@ pub async fn page(session: Session, State(state): State<Arc<CloudState>>) -> Res
         );
         Html(modelrelay_web::templates::page_shell_custom(
             "Dashboard",
+            "/dashboard",
             &html,
             true,
             "",
@@ -172,11 +177,11 @@ pub async fn page(session: Session, State(state): State<Arc<CloudState>>) -> Res
 /// POST /dashboard/billing-portal — create a Stripe billing portal session and redirect.
 pub async fn billing_portal(session: Session, State(state): State<Arc<CloudState>>) -> Response {
     let Some(ref key) = state.stripe_key else {
-        return error_page("Billing not configured").into_response();
+        return error_page("/dashboard/billing-portal", "Billing not configured").into_response();
     };
 
     let Some(ref pool) = state.db else {
-        return error_page("Database not available").into_response();
+        return error_page("/dashboard/billing-portal", "Database not available").into_response();
     };
 
     let user_id = match require_user(&session).await {
@@ -196,6 +201,7 @@ pub async fn billing_portal(session: Session, State(state): State<Arc<CloudState
     let Some(customer_id) = customer_id else {
         return Html(modelrelay_web::templates::page_shell(
             "Error",
+            "/dashboard/billing-portal",
             "<div class=\"card\"><h2>No billing account</h2>\
              <p>No Stripe customer found for your account.</p>\
              <p><a href=\"/dashboard\">&larr; Back to dashboard</a></p></div>",
@@ -223,23 +229,39 @@ pub async fn billing_portal(session: Session, State(state): State<Arc<CloudState
                 if let Some(url) = body["url"].as_str() {
                     Redirect::to(url).into_response()
                 } else {
-                    error_page("Stripe did not return a portal URL.").into_response()
+                    error_page(
+                        "/dashboard/billing-portal",
+                        "Stripe did not return a portal URL.",
+                    )
+                    .into_response()
                 }
             }
             Err(e) => {
                 tracing::error!("stripe portal response parse error: {e}");
-                error_page("Could not process billing portal response.").into_response()
+                error_page(
+                    "/dashboard/billing-portal",
+                    "Could not process billing portal response.",
+                )
+                .into_response()
             }
         },
         Ok(r) => {
             let status = r.status();
             let body = r.text().await.unwrap_or_default();
             tracing::error!("stripe billing portal API error: {status} — {body}");
-            error_page("Could not open billing portal. Please try again later.").into_response()
+            error_page(
+                "/dashboard/billing-portal",
+                "Could not open billing portal. Please try again later.",
+            )
+            .into_response()
         }
         Err(e) => {
             tracing::error!("stripe billing portal request error: {e}");
-            error_page("Could not reach payment provider. Please try again later.").into_response()
+            error_page(
+                "/dashboard/billing-portal",
+                "Could not reach payment provider. Please try again later.",
+            )
+            .into_response()
         }
     }
 }
@@ -249,7 +271,7 @@ pub async fn billing_portal(session: Session, State(state): State<Arc<CloudState
 /// POST /dashboard/keys/generate — admin-only: provision a new API key.
 pub async fn keys_generate(session: Session, State(state): State<Arc<CloudState>>) -> Response {
     let Some(ref pool) = state.db else {
-        return error_page("Database not available").into_response();
+        return error_page("/dashboard/keys/generate", "Database not available").into_response();
     };
 
     let user_id = match require_user(&session).await {
@@ -270,12 +292,18 @@ pub async fn keys_generate(session: Session, State(state): State<Arc<CloudState>
     }
 
     let Some(ref admin_url) = state.admin_url else {
-        return error_page("Admin API not configured. Cannot generate API keys at this time.")
-            .into_response();
+        return error_page(
+            "/dashboard/keys/generate",
+            "Admin API not configured. Cannot generate API keys at this time.",
+        )
+        .into_response();
     };
     let Some(ref admin_token) = state.admin_token else {
-        return error_page("Admin API not configured. Cannot generate API keys at this time.")
-            .into_response();
+        return error_page(
+            "/dashboard/keys/generate",
+            "Admin API not configured. Cannot generate API keys at this time.",
+        )
+        .into_response();
     };
 
     // Get user email for key name
@@ -287,7 +315,11 @@ pub async fn keys_generate(session: Session, State(state): State<Arc<CloudState>
         Ok(e) => e,
         Err(e) => {
             tracing::error!("keys_generate user lookup error: {e}");
-            return error_page("Could not look up your account.").into_response();
+            return error_page(
+                "/dashboard/keys/generate",
+                "Could not look up your account.",
+            )
+            .into_response();
         }
     };
 
@@ -308,6 +340,7 @@ pub async fn keys_generate(session: Session, State(state): State<Arc<CloudState>
             {
                 tracing::error!("keys_generate db insert error: {e}");
                 return error_page(
+                    "/dashboard/keys/generate",
                     "Key was provisioned on the server but could not be saved. Contact support.",
                 )
                 .into_response();
@@ -318,6 +351,7 @@ pub async fn keys_generate(session: Session, State(state): State<Arc<CloudState>
         Err(e) => {
             tracing::error!("keys_generate provision error: {e}");
             error_page(
+                "/dashboard/keys/generate",
                 "Could not generate API key. The relay server may be unreachable. Please try again later.",
             )
             .into_response()
@@ -333,8 +367,9 @@ pub async fn keys_revoke(
     State(state): State<Arc<CloudState>>,
     Path(key_uuid): Path<uuid::Uuid>,
 ) -> Response {
+    let path = format!("/dashboard/keys/{key_uuid}/revoke");
     let Some(ref pool) = state.db else {
-        return error_page("Database not available").into_response();
+        return error_page(&path, "Database not available").into_response();
     };
 
     let user_id = match require_user(&session).await {
@@ -366,7 +401,7 @@ pub async fn keys_revoke(
     .flatten();
 
     let Some((key_id,)) = key_row else {
-        return error_page("API key not found or already revoked.").into_response();
+        return error_page(&path, "API key not found or already revoked.").into_response();
     };
 
     // Attempt to revoke on the server
@@ -386,7 +421,7 @@ pub async fn keys_revoke(
         .await
     {
         tracing::error!("keys_revoke db update error: {e}");
-        return error_page("Could not revoke key. Please try again.").into_response();
+        return error_page(&path, "Could not revoke key. Please try again.").into_response();
     }
 
     tracing::info!(key_id = %key_id, "admin revoked API key");
@@ -570,9 +605,10 @@ pub async fn integrate(session: Session, State(state): State<Arc<CloudState>>) -
 
 // ─── HTML rendering ─────────────────────────────────────────────────────────
 
-fn error_page(message: &str) -> Html<String> {
+fn error_page(path: &str, message: &str) -> Html<String> {
     Html(modelrelay_web::templates::page_shell(
         "Error",
+        path,
         &format!(
             "<div class=\"card\" style=\"border-left: 3px solid #f87171;\">\
              <h2 style=\"display:flex;align-items:center;gap:10px;\">\
diff --git a/crates/modelrelay-cloud/src/routes/mod.rs b/crates/modelrelay-cloud/src/routes/mod.rs
index ae2d3e9..a092f97 100644
--- a/crates/modelrelay-cloud/src/routes/mod.rs
+++ b/crates/modelrelay-cloud/src/routes/mod.rs
@@ -76,7 +76,8 @@ async fn download_redirect() -> Redirect {
     Redirect::temporary("/#download")
 }
 
-async fn not_found() -> impl IntoResponse {
+async fn not_found(request: Request) -> impl IntoResponse {
+    let path = request.uri().path().to_owned();
     let body = r#"<div style="display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:60vh;text-align:center;padding:2rem">
 <h1 style="font-size:6rem;font-weight:800;color:#7c3aed;line-height:1;margin:0">404</h1>
 <h2 style="font-size:1.5rem;font-weight:600;margin:1rem 0 .5rem">Page Not Found</h2>
@@ -87,6 +88,7 @@ async fn not_found() -> impl IntoResponse {
         StatusCode::NOT_FOUND,
         Html(modelrelay_web::templates::page_shell(
             "404 — Not Found",
+            &path,
             body,
             false,
         )),
@@ -172,6 +174,7 @@ async fn session_guard(request: Request, next: Next) -> Response {
                 StatusCode::SERVICE_UNAVAILABLE,
                 Html(modelrelay_web::templates::page_shell(
                     "Service Unavailable",
+                    &path,
                     body,
                     false,
                 )),
diff --git a/crates/modelrelay-cloud/templates/index.html b/crates/modelrelay-cloud/templates/index.html
index 231a0c5..3a05234 100644
--- a/crates/modelrelay-cloud/templates/index.html
+++ b/crates/modelrelay-cloud/templates/index.html
@@ -6,12 +6,12 @@
   <title>ModelRelay — Managed LLM Relay for Your AI Workers</title>
   <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect width='100' height='100' rx='20' fill='%237c3aed'/><text x='50' y='72' font-size='60' font-weight='bold' text-anchor='middle' fill='white'>M</text></svg>">
   <meta name="description" content="Run your local GPU workers behind a managed cloud relay. OpenAI, Anthropic, and Responses API compatible. One endpoint, automatic load balancing, zero DevOps.">
-  <link rel="canonical" href="https://modelrelay.io">
+  <link rel="canonical" href="https://modelrelay.io/">
   <!-- Open Graph -->
   <meta property="og:title" content="ModelRelay — Managed LLM Relay for Your AI Workers">
   <meta property="og:description" content="Route inference to your own GPU workers through a secure relay. OpenAI, Anthropic, and Responses API compatible.">
   <meta property="og:type" content="website">
-  <meta property="og:url" content="https://modelrelay.io">
+  <meta property="og:url" content="https://modelrelay.io/">
   <!-- Twitter Card -->
   <meta name="twitter:card" content="summary">
   <meta name="twitter:title" content="ModelRelay — Managed LLM Relay for Your AI Workers">
diff --git a/crates/modelrelay-cloud/templates/pricing.html b/crates/modelrelay-cloud/templates/pricing.html
index d0dab84..311d42e 100644
--- a/crates/modelrelay-cloud/templates/pricing.html
+++ b/crates/modelrelay-cloud/templates/pricing.html
@@ -5,6 +5,8 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>Pricing — ModelRelay</title>
   <meta name="description" content="Simple, transparent pricing for ModelRelay. $20/month flat rate — unlimited workers, unlimited requests, no per-request fees.">
+  <meta property="og:url" content="https://modelrelay.io/pricing">
+  <link rel="canonical" href="https://modelrelay.io/pricing">
   <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='6' fill='%237c3aed'/%3E%3Cpath d='M8 10h4l4 6-4 6H8l4-6-4-6zm12 0h4l4 6-4 6h-4l4-6-4-6z' fill='white'/%3E%3C/svg%3E">
   <style>
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
diff --git a/crates/modelrelay-cloud/tests/http_routes.rs b/crates/modelrelay-cloud/tests/http_routes.rs
index 5103f74..9ae860d 100644
--- a/crates/modelrelay-cloud/tests/http_routes.rs
+++ b/crates/modelrelay-cloud/tests/http_routes.rs
@@ -4,6 +4,7 @@ use axum::body::Body;
 use axum::http::{Request, StatusCode};
 use http_body_util::BodyExt;
 use tower::ServiceExt;
+use tower_sessions::{MemoryStore, SessionManagerLayer};
 
 use modelrelay_cloud::routes;
 use modelrelay_cloud::state::CloudState;
@@ -32,6 +33,24 @@ fn app() -> axum::Router {
     routes::router(test_state())
 }
 
+/// Build a router with an in-memory session layer attached, so session-dependent
+/// routes don't 503 under the session guard middleware. Used by tests that
+/// want to inspect rendered page HTML (canonical/og meta tags, etc.).
+fn app_with_session() -> axum::Router {
+    let session_layer = SessionManagerLayer::new(MemoryStore::default());
+    routes::router(test_state()).layer(session_layer)
+}
+
+async fn get_with_session(path: &str) -> (StatusCode, String) {
+    let resp = app_with_session()
+        .oneshot(Request::builder().uri(path).body(Body::empty()).unwrap())
+        .await
+        .unwrap();
+    let status = resp.status();
+    let body = resp.into_body().collect().await.unwrap().to_bytes();
+    (status, String::from_utf8_lossy(&body).into_owned())
+}
+
 async fn get(path: &str) -> (StatusCode, String) {
     let resp = app()
         .oneshot(Request::builder().uri(path).body(Body::empty()).unwrap())
@@ -405,6 +424,84 @@ async fn responses_include_security_headers() {
     );
 }
 
+// ─── Per-page og:url + canonical meta tags ────────────────────────────────
+
+#[tokio::test]
+async fn landing_page_has_root_og_url_and_canonical() {
+    let (status, body) = get_with_session("/").await;
+    assert_eq!(status, StatusCode::OK);
+    assert!(
+        body.contains(r#"<meta property="og:url" content="https://modelrelay.io/""#),
+        "landing page missing og:url for root path"
+    );
+    assert!(
+        body.contains(r#"<link rel="canonical" href="https://modelrelay.io/""#),
+        "landing page missing canonical for root path"
+    );
+}
+
+#[tokio::test]
+async fn login_page_has_per_page_og_url_and_canonical() {
+    let (status, body) = get_with_session("/login").await;
+    assert_eq!(status, StatusCode::OK, "/login should render with session");
+    assert!(
+        body.contains(r#"<meta property="og:url" content="https://modelrelay.io/login""#),
+        "/login should have og:url pointing at /login, got body starting: {}",
+        &body[..body.len().min(500)]
+    );
+    assert!(
+        body.contains(r#"<link rel="canonical" href="https://modelrelay.io/login""#),
+        "/login should have canonical link pointing at /login"
+    );
+}
+
+#[tokio::test]
+async fn signup_page_has_per_page_og_url_and_canonical() {
+    let (status, body) = get_with_session("/signup").await;
+    assert_eq!(status, StatusCode::OK, "/signup should render with session");
+    assert!(
+        body.contains(r#"<meta property="og:url" content="https://modelrelay.io/signup""#),
+        "/signup should have og:url pointing at /signup"
+    );
+    assert!(
+        body.contains(r#"<link rel="canonical" href="https://modelrelay.io/signup""#),
+        "/signup should have canonical link pointing at /signup"
+    );
+}
+
+#[tokio::test]
+async fn pricing_page_has_og_url_and_canonical() {
+    let (status, body) = get_with_session("/pricing").await;
+    assert_eq!(
+        status,
+        StatusCode::OK,
+        "/pricing should render with session"
+    );
+    assert!(
+        body.contains(r#"<meta property="og:url" content="https://modelrelay.io/pricing""#),
+        "/pricing should have og:url pointing at /pricing"
+    );
+    assert!(
+        body.contains(r#"<link rel="canonical" href="https://modelrelay.io/pricing""#),
+        "/pricing should have canonical link pointing at /pricing"
+    );
+}
+
+#[tokio::test]
+async fn checkout_cancel_has_per_page_og_url_and_canonical() {
+    // /checkout/cancel is session-exempt, so it renders even without the session layer.
+    let (status, body) = get("/checkout/cancel").await;
+    assert_eq!(status, StatusCode::OK);
+    assert!(
+        body.contains(r#"<meta property="og:url" content="https://modelrelay.io/checkout/cancel""#),
+        "/checkout/cancel should have og:url pointing at /checkout/cancel"
+    );
+    assert!(
+        body.contains(r#"<link rel="canonical" href="https://modelrelay.io/checkout/cancel""#),
+        "/checkout/cancel should have canonical link pointing at /checkout/cancel"
+    );
+}
+
 // ─── Webhook with no webhook_secret configured returns 500 ────────────────
 
 #[tokio::test]
diff --git a/crates/modelrelay-web/src/routes/mod.rs b/crates/modelrelay-web/src/routes/mod.rs
index 361b4b7..6a1d065 100644
--- a/crates/modelrelay-web/src/routes/mod.rs
+++ b/crates/modelrelay-web/src/routes/mod.rs
@@ -20,6 +20,7 @@ pub fn router() -> Router {
 async fn landing() -> Html<String> {
     Html(crate::templates::page_shell(
         "ModelRelay Admin",
+        "/",
         "<div class=\"card\">\
            <h2>Welcome to ModelRelay</h2>\
            <p>This is the open-source admin dashboard for your ModelRelay deployment.</p>\
diff --git a/crates/modelrelay-web/src/templates.rs b/crates/modelrelay-web/src/templates.rs
index 2e98779..39db386 100644
--- a/crates/modelrelay-web/src/templates.rs
+++ b/crates/modelrelay-web/src/templates.rs
@@ -396,7 +396,14 @@ pub fn dashboard_page() -> String {
 
     let extra_body_end = ["<script>", dashboard_js, "</script>"].concat();
 
-    page_shell_custom("Dashboard", &dash_body, true, &extra_css, &extra_body_end)
+    page_shell_custom(
+        "Dashboard",
+        "/dashboard",
+        &dash_body,
+        true,
+        &extra_css,
+        &extra_body_end,
+    )
 }
 
 /// Optional configuration for embedding the setup wizard in a cloud context.
@@ -1399,7 +1406,14 @@ Get-Service ModelRelayWorker</code>
     let cloud_cfg_script = cloud_config_script(cloud_config);
     let extra_body_end = format!("{cloud_cfg_script}<script>{wizard_js}</script>");
 
-    page_shell_custom("Setup", &setup_body, logged_in, &extra_css, &extra_body_end)
+    page_shell_custom(
+        "Setup",
+        "/setup",
+        &setup_body,
+        logged_in,
+        &extra_css,
+        &extra_body_end,
+    )
 }
 
 /// Build the integration snippets page (no cloud config).
@@ -2623,6 +2637,7 @@ data: {{"type":"response.completed","response":{{"id":"resp_abc123","object":"re
 
     page_shell_custom(
         "Integrate",
+        "/integrate",
         &integrate_body,
         logged_in,
         &extra_css,
@@ -2654,10 +2669,15 @@ fn cloud_config_script(config: Option<&CloudWizardConfig>) -> String {
 ///
 /// `logged_in` controls the nav links: when `true`, shows Dashboard + Setup + Integrate +
 /// Docs + Log out; when `false`, shows Pricing + Docs + Log in + Sign up + GitHub.
+///
+/// `path` is the canonical URL path for this page (e.g. `/login`, `/pricing`, `/`).
+/// It is rendered into `og:url` and `<link rel="canonical">` so that each page has a
+/// distinct canonical URL rather than every page claiming to be the site root.
 #[must_use]
 #[allow(clippy::too_many_lines)]
 pub fn page_shell_custom(
     title: &str,
+    path: &str,
     body_html: &str,
     logged_in: bool,
     extra_css: &str,
@@ -2714,7 +2734,8 @@ pub fn page_shell_custom(
   <meta property="og:title" content="{title} — ModelRelay">
   <meta property="og:description" content="Route inference to your own GPU workers through a secure relay. OpenAI, Anthropic, and Responses API compatible.">
   <meta property="og:type" content="website">
-  <meta property="og:url" content="https://modelrelay.io">
+  <meta property="og:url" content="https://modelrelay.io{path}">
+  <link rel="canonical" href="https://modelrelay.io{path}">
   <meta name="twitter:card" content="summary">
   <meta name="twitter:title" content="{title} — ModelRelay">
   <meta name="twitter:description" content="Route inference to your own GPU workers through a secure relay. OpenAI, Anthropic, and Responses API compatible.">
@@ -2995,8 +3016,10 @@ pub fn page_shell_custom(
 
 /// Convenience wrapper: auto-adds `<h1>` before body content.
 /// Most routes use this. For custom headers, use [`page_shell_custom`] directly.
+///
+/// `path` is the canonical URL path for this page (e.g. `/login`, `/dashboard`, `/`).
 #[must_use]
-pub fn page_shell(title: &str, body_content: &str, logged_in: bool) -> String {
+pub fn page_shell(title: &str, path: &str, body_content: &str, logged_in: bool) -> String {
     let body_html = format!("<h1>{title}</h1>\n      {body_content}");
-    page_shell_custom(title, &body_html, logged_in, "", "")
+    page_shell_custom(title, path, &body_html, logged_in, "", "")
 }