@@ -22,7 +22,7 @@ export function Switch({
 }: SwitchProps) {
   const [storeValue, setStoreValue] = useSubBlockValue<boolean>(blockId, subBlockId)
 
-  const value = isPreview ? previewValue : propValue !== undefined ? propValue : storeValue
+  const value = isPreview ? previewValue : (storeValue ?? propValue)
 
   const handleChange = (checked: boolean) => {
     if (!isPreview && !disabled) {
 
@@ -790,6 +790,7 @@ function SubBlockComponent({
             blockId={blockId}
             subBlockId={config.id}
             title={config.title ?? ''}
+            value={typeof config.defaultValue === 'boolean' ? config.defaultValue : undefined}
             isPreview={isPreview}
             previewValue={previewValue as any}
             disabled={isDisabled}
 
@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { ApiBlock } from '@/blocks/blocks/api'
+
+describe('API block redirect policy', () => {
+  it('uses a versioned safe default without changing legacy blocks', () => {
+    const version = ApiBlock.subBlocks.find((subBlock) => subBlock.id === 'redirectPolicyVersion')
+    const sendCredentials = ApiBlock.subBlocks.find(
+      (subBlock) => subBlock.id === 'sendCredentialsOnCrossOriginRedirect'
+    )
+
+    expect(version?.hidden).toBe(true)
+    expect(version?.defaultValue).toBe('standard-v1')
+    expect(sendCredentials?.type).toBe('switch')
+    expect(sendCredentials?.mode).toBe('advanced')
+    expect(sendCredentials?.defaultValue).toBe(true)
+  })
+})
@@ -133,6 +133,22 @@ Example:
       description: 'Allow retries for POST/PATCH requests (may create duplicate requests)',
       mode: 'advanced',
     },
+    {
+      id: 'redirectPolicyVersion',
+      title: 'Redirect policy version',
+      type: 'short-input',
+      defaultValue: 'standard-v1',
+      hidden: true,
+    },
+    {
+      id: 'sendCredentialsOnCrossOriginRedirect',
+      title: 'Send credentials on cross-origin redirects',
+      type: 'switch',
+      defaultValue: true,
+      description:
+        'Forward credential-bearing headers when a redirect changes scheme, host, or port. Enabled by default for compatibility; disable it when redirected destinations should not receive the same credentials.',
+      mode: 'advanced',
+    },
     {
       id: 'proxyUrl',
       title: 'Proxy URL',
@@ -163,6 +179,14 @@ Example:
       type: 'boolean',
       description: 'Allow retries for non-idempotent methods like POST/PATCH',
     },
+    redirectPolicyVersion: {
+      type: 'string',
+      description: 'Persisted redirect-policy compatibility version',
+    },
+    sendCredentialsOnCrossOriginRedirect: {
+      type: 'boolean',
+      description: 'Send credential-bearing headers on redirects to a different origin',
+    },
     proxyUrl: {
       type: 'string',
       description: 'Optional http:// proxy URL to route the request through',
 
@@ -53,7 +53,27 @@ const slackBlockConfig = {
   subBlocks: [{ id: 'channel', type: 'channel-selector' }],
 }
 
+const apiBlockConfig = {
+  type: 'api',
+  name: 'API',
+  outputs: {},
+  subBlocks: [
+    {
+      id: 'redirectPolicyVersion',
+      type: 'short-input',
+      hidden: true,
+      defaultValue: 'standard-v1',
+    },
+    {
+      id: 'sendCredentialsOnCrossOriginRedirect',
+      type: 'switch',
+      defaultValue: true,
+    },
+  ],
+}
+
 const blocksByType: Record<string, unknown> = {
+  api: apiBlockConfig,
   agent: agentBlockConfig,
   condition: conditionBlockConfig,
   knowledge: knowledgeBlockConfig,
@@ -62,6 +82,7 @@ const blocksByType: Record<string, unknown> = {
 
 vi.mock('@/blocks/registry', () => ({
   getAllBlocks: () => [
+    apiBlockConfig,
     agentBlockConfig,
     conditionBlockConfig,
     knowledgeBlockConfig,
@@ -143,6 +164,17 @@ describe('createBlockFromParams', () => {
     expect(filters[0].tagName).toBe('Department')
     expect(filters[0].id).toEqual(expect.any(String))
   })
+
+  it('seeds hidden compatibility defaults on programmatically created blocks', () => {
+    const block = createBlockFromParams('api-1', {
+      type: 'api',
+      name: 'API',
+      triggerMode: false,
+    })
+
+    expect(block.subBlocks.redirectPolicyVersion.value).toBe('standard-v1')
+    expect(block.subBlocks.sendCredentialsOnCrossOriginRedirect.value).toBeNull()
+  })
 })
 
 describe('filterDisallowedTools', () => {
 
@@ -213,7 +213,10 @@ export function createBlockFromParams(
         blockState.subBlocks[subBlock.id] = {
           id: subBlock.id,
           type: subBlock.type,
-          value: null,
+          value:
+            subBlock.hidden && subBlock.defaultValue !== undefined
+              ? structuredClone(subBlock.defaultValue)
+              : null,
         }
       } else {
         blockState.subBlocks[subBlock.id].type = subBlock.type
 
@@ -0,0 +1,12 @@
+/**
+ * Redirect behavior for outbound HTTP requests.
+ *
+ * `legacy` preserves Sim's historical replay semantics for persisted workflows, while
+ * `standard` follows Fetch-compatible method rules. Credential forwarding is controlled
+ * independently in both modes.
+ */
+export interface HttpRedirectPolicy {
+  mode: 'legacy' | 'standard'
+  sendCredentialsOnCrossOriginRedirect: boolean
+  sensitiveHeaders?: readonly string[]
+}
@@ -8,7 +8,6 @@ import { createLogger } from '@sim/logger'
 import { preferIpv4, resolveHostAddresses } from '@sim/security/dns'
 import { isLoopbackIp, isPrivateIp, isPrivateIpHost, unwrapIpv6Brackets } from '@sim/security/ssrf'
 import { toError } from '@sim/utils/errors'
-import { omit } from '@sim/utils/object'
 import { HttpProxyAgent } from 'http-proxy-agent'
 import { HttpsProxyAgent } from 'https-proxy-agent'
 import * as ipaddr from 'ipaddr.js'
@@ -19,6 +18,7 @@ import {
   request as undiciRequest,
 } from 'undici'
 import { isHosted, isPrivateDatabaseHostsAllowed } from '@/lib/core/config/env-flags'
+import type { HttpRedirectPolicy } from '@/lib/core/security/http-redirect-policy'
 import { type ValidationResult, validateExternalUrl } from '@/lib/core/security/input-validation'
 import { nodeReadableToWebStream } from '@/lib/core/utils/node-stream'
 import { PayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
@@ -365,8 +365,13 @@ export interface SecureFetchOptions {
    */
   maxResponseBytes?: number
   signal?: AbortSignal
-  /** Drop the Authorization header when following a redirect, so it is not sent to the redirect target's origin. */
+  /**
+   * Drop the Authorization header when following any redirect, including a same-origin hop.
+   * Use this for endpoints that redirect to a target carrying its own signed URL.
+   */
   stripAuthOnRedirect?: boolean
+  /** Omit for the historical behavior used by existing workflows. */
+  redirectPolicy?: HttpRedirectPolicy
   /**
    * Pre-validated, IP-pinned `http://` proxy URL (see {@link validateAndPinProxyUrl}).
    * When set, the connection routes through this proxy and target-IP pinning is
@@ -526,6 +531,56 @@ function assertGuardedRedirectTarget(url: URL, allowedPinnedIp?: string): void {
   }
 }
 
+/** Headers that describe a request body and must not outlive it. */
+const ENTITY_HEADERS = [
+  'content-length',
+  'content-type',
+  'content-encoding',
+  'content-language',
+  'content-location',
+  'transfer-encoding',
+] as const
+
+/** Case-insensitive header removal — callers supply arbitrary casing. */
+function stripHeaders(
+  headers: Record<string, string>,
+  remove: readonly string[]
+): Record<string, string> {
+  const drop = new Set(remove.map((name) => name.toLowerCase()))
+  const kept: Record<string, string> = {}
+  for (const [name, value] of Object.entries(headers)) {
+    if (!drop.has(name.toLowerCase())) kept[name] = value
+  }
+  return kept
+}
+
+interface RedirectHopPolicy {
+  /** Method for the next hop. */
+  method: string
+  /** Whether the body — and the entity headers describing it — must be dropped. */
+  dropBody: boolean
+}
+
+/**
+ * Decides how a request may be replayed on a redirect target, per RFC 9110 section 15.4.
+ *
+ * `HEAD` is deliberately preserved on 303. Fetch only changes a 303 to GET when the
+ * current method is neither GET nor HEAD.
+ */
+function resolveRedirectHop(args: { status: number; method: string }): RedirectHopPolicy {
+  const method = args.method.toUpperCase()
+  const isGetOrHead = method === 'GET' || method === 'HEAD'
+  const dropBody =
+    (args.status === 303 && !isGetOrHead) ||
+    ((args.status === 301 || args.status === 302) && method === 'POST')
+  return {
+    method: dropBody ? 'GET' : method,
+    dropBody,
+  }
+}
+
+const CROSS_ORIGIN_CREDENTIAL_HEADERS = ['authorization', 'proxy-authorization', 'cookie'] as const
+
 /**
  * Manual, revalidating redirect follower used by the guarded fetch. Auto-follow
  * is unsafe here on two counts the connect-time lookup cannot cover: IP-literal
@@ -574,32 +629,24 @@ export async function followRedirectsGuarded(
     }
     const nextUrl = new URL(location, currentUrl)
     assertGuardedRedirectTarget(nextUrl, options?.allowRedirectToIp)
-    // Per the fetch spec: 303 (and 301/302 on POST) switch to a bodyless GET, dropping
-    // the entity headers that described the removed body (a retained Content-Length /
-    // Content-Type on a bodyless GET is malformed and undici rejects it).
-    if (status === 303 || ((status === 301 || status === 302) && method === 'POST')) {
-      method = 'GET'
-      body = undefined
-      if (headers !== undefined) {
-        const sanitized = new Headers(headers as HeadersInit)
-        sanitized.delete('content-length')
-        sanitized.delete('content-type')
-        sanitized.delete('content-encoding')
-        sanitized.delete('transfer-encoding')
-        // double-cast-allowed: Headers is a valid undici HeadersInit at runtime but the DOM/undici types differ
-        headers = sanitized as unknown as UndiciRequestInit['headers']
-      }
-    }
+    const hopPolicy = resolveRedirectHop({
+      status,
+      method,
+    })
+    method = hopPolicy.method
+    if (hopPolicy.dropBody) body = undefined
     if (nextUrl.origin !== currentUrl.origin) {
       headers = undefined
-      // 307/308 preserve method+body; forwarding a body cross-origin can hand OAuth
-      // client secrets / tokens to an open-redirect target now that redirects really
-      // dial the new origin. No legitimate MCP/OAuth flow does this — refuse it.
       if (body !== undefined && body !== null) {
         throw new Error(
           'Blocked by SSRF policy: cross-origin redirect would forward a request body'
         )
       }
+    } else if (hopPolicy.dropBody && headers !== undefined) {
+      const sanitized = new Headers(headers as HeadersInit)
+      for (const name of ENTITY_HEADERS) sanitized.delete(name)
+      // double-cast-allowed: Headers is a valid undici HeadersInit at runtime but the DOM/undici types differ
+      headers = sanitized as unknown as UndiciRequestInit['headers']
     }
     currentUrl = nextUrl
   }
@@ -1018,12 +1065,41 @@ export async function secureFetchWithPinnedIP(
               settledReject(new Error(`Redirect blocked: ${validation.error}`))
               return
             }
-            const redirectOptions = options.stripAuthOnRedirect
-              ? {
-                  ...options,
-                  headers: omit(options.headers ?? {}, ['Authorization', 'authorization']),
-                }
-              : options
+            const redirectPolicy = options.redirectPolicy
+            const hop =
+              redirectPolicy?.mode === 'standard'
+                ? resolveRedirectHop({ status: statusCode, method: options.method ?? 'GET' })
+                : { method: options.method ?? 'GET', dropBody: false }
+            const isCrossOrigin = new URL(redirectUrl).origin !== parsed.origin
+            let redirectHeaders = options.headers
+            if (redirectHeaders && hop.dropBody) {
+              redirectHeaders = stripHeaders(redirectHeaders, ENTITY_HEADERS)
+            }
+            if (
+              redirectHeaders &&
+              redirectPolicy &&
+              isCrossOrigin &&
+              (redirectPolicy.mode === 'standard' ||
+                !redirectPolicy.sendCredentialsOnCrossOriginRedirect)
+            ) {
+              const sensitiveHeaders = redirectPolicy.sendCredentialsOnCrossOriginRedirect
+                ? ['host']
+                : [
+                    'host',
+                    ...CROSS_ORIGIN_CREDENTIAL_HEADERS,
+                    ...(redirectPolicy.sensitiveHeaders ?? []),
+                  ]
+              redirectHeaders = stripHeaders(redirectHeaders, sensitiveHeaders)
+            }
+            if (redirectHeaders && options.stripAuthOnRedirect) {
+              redirectHeaders = stripHeaders(redirectHeaders, ['authorization'])
+            }
+            const redirectOptions: SecureFetchOptions & { allowHttp?: boolean } = {
+              ...options,
+              method: hop.method,
+              body: hop.dropBody ? undefined : options.body,
+              headers: redirectHeaders,
+            }
             return secureFetchWithPinnedIP(
               redirectUrl,
               validation.resolvedIP!,