Update Routing Rule

Update Routing Rule

Updates an existing routing rule. All fields are optional - only provide the fields you want to change.

Paid Plans Only

This endpoint requires a paid plan. Free plan users will receive a 403 Forbidden error.

Endpoint

PATCH /v1/routing-rules/{id}

Path Parameters

Parameter	Type	Required	Description
id	integer	Yes	The routing rule ID

Request Body

All fields are optional. Only include fields you want to update:

Parameter	Type	Description
name	string	Human-readable name (max 128 characters)
is_enabled	boolean	Whether the rule is active
priority	integer	Rule priority (-1000 to 1000)
match_json	object|string	Match conditions
action_json	object|string	Actions to apply

Examples

Example 1: Enable/Disable Rule

TypeScript

import Tokenrouter from 'tokenrouter';

const client = new Tokenrouter({
  apiKey: process.env.TOKENROUTER_API_KEY
});

// Disable a rule
await client.routingRules.update(123, {
  is_enabled: false
});

// Enable a rule
await client.routingRules.update(123, {
  is_enabled: true
});

Python

from tokenrouter import Tokenrouter

client = Tokenrouter(
    api_key=os.getenv("TOKENROUTER_API_KEY")
)

# Disable a rule
client.routing_rules.update(123, is_enabled=False)

# Enable a rule
client.routing_rules.update(123, is_enabled=True)

cURL

# Disable a rule
curl -X PATCH https://api.tokenrouter.io/v1/routing-rules/123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tr_..." \
  -d '{"is_enabled": false}'

Example 2: Change Priority

TypeScript

// Increase rule priority to execute it earlier
await client.routingRules.update(123, {
  priority: 200
});

Python

# Increase rule priority to execute it earlier
client.routing_rules.update(123, priority=200)

cURL

curl -X PATCH https://api.tokenrouter.io/v1/routing-rules/123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tr_..." \
  -d '{"priority": 200}'

Example 3: Update Conditions

TypeScript

// Change match conditions
await client.routingRules.update(123, {
  match_json: {
    task: 'code_review',
    mode: 'quality'  // Add additional condition
  }
});

Python

# Change match conditions
client.routing_rules.update(
    123,
    match_json={
        "task": "code_review",
        "mode": "quality"  # Add additional condition
    }
)

cURL

curl -X PATCH https://api.tokenrouter.io/v1/routing-rules/123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tr_..." \
  -d '{
    "match_json": {
      "task": "code_review",
      "mode": "quality"
    }
  }'

Example 4: Update Actions

TypeScript

// Change from forcing provider to just overriding mode
await client.routingRules.update(123, {
  action_json: {
    set_mode: 'cost'
  }
});

Python

# Change from forcing provider to just overriding mode
client.routing_rules.update(
    123,
    action_json={"set_mode": "cost"}
)

cURL

curl -X PATCH https://api.tokenrouter.io/v1/routing-rules/123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tr_..." \
  -d '{"action_json": {"set_mode": "cost"}}'

Example 5: Update Multiple Fields

TypeScript

await client.routingRules.update(123, {
  name: 'Updated Rule Name',
  priority: 150,
  is_enabled: true,
  match_json: {
    contains: 'analyze'
  },
  action_json: {
    set_provider: 'anthropic',
    set_mode: 'quality'
  }
});

Python

client.routing_rules.update(
    123,
    name="Updated Rule Name",
    priority=150,
    is_enabled=True,
    match_json={"contains": "analyze"},
    action_json={
        "set_provider": "anthropic",
        "set_mode": "quality"
    }
)

cURL

curl -X PATCH https://api.tokenrouter.io/v1/routing-rules/123 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer tr_..." \
  -d '{
    "name": "Updated Rule Name",
    "priority": 150,
    "is_enabled": true,
    "match_json": {"contains": "analyze"},
    "action_json": {
      "set_provider": "anthropic",
      "set_mode": "quality"
    }
  }'

Response

{
  "data": {
    "id": 123,
    "user_id": 456,
    "name": "Updated Rule Name",
    "is_enabled": true,
    "priority": 150,
    "match_json": {
      "contains": "analyze"
    },
    "action_json": {
      "set_provider": "anthropic",
      "set_mode": "quality"
    },
    "created_at": "2025-11-10T12:00:00Z",
    "updated_at": "2025-11-10T15:30:00Z"
  }
}

Error Responses

403 Forbidden - Free Plan

{
  "error": {
    "message": "Routing rules are not available on the free plan",
    "type": "authorization_error",
    "http_status": 403
  }
}

404 Not Found

{
  "error": {
    "message": "Routing rule not found",
    "type": "not_found_error",
    "http_status": 404
  }
}

422 Validation Error

{
  "error": {
    "message": "Validation failed",
    "type": "validation_error",
    "http_status": 422,
    "errors": {
      "priority": ["The priority must be between -1000 and 1000"]
    }
  }
}

Practical Patterns

Temporarily Disable Rule

TypeScript

// Disable temporarily for testing
const original = await client.routingRules.retrieve(ruleId);

await client.routingRules.update(ruleId, {
  is_enabled: false
});

// Test your requests...

// Re-enable
await client.routingRules.update(ruleId, {
  is_enabled: true
});

Python

# Disable temporarily for testing
original = client.routing_rules.retrieve(rule_id)

client.routing_rules.update(rule_id, is_enabled=False)

# Test your requests...

# Re-enable
client.routing_rules.update(rule_id, is_enabled=True)

Adjust Priority Relative to Others

TypeScript

// Get all rules
const rules = await client.routingRules.list();

// Find highest priority
const highestPriority = Math.max(...rules.data.map(r => r.priority));

// Make this rule highest priority
await client.routingRules.update(ruleId, {
  priority: highestPriority + 10
});

Python

# Get all rules
rules = client.routing_rules.list()

# Find highest priority
highest_priority = max(rule.priority for rule in rules.data)

# Make this rule highest priority
client.routing_rules.update(rule_id, priority=highest_priority + 10)

Swap Rule Priorities

TypeScript

// Swap priorities between two rules
const rule1 = await client.routingRules.retrieve(id1);
const rule2 = await client.routingRules.retrieve(id2);

await client.routingRules.update(id1, {
  priority: rule2.data.priority
});

await client.routingRules.update(id2, {
  priority: rule1.data.priority
});

Python

# Swap priorities between two rules
rule1 = client.routing_rules.retrieve(id1)
rule2 = client.routing_rules.retrieve(id2)

client.routing_rules.update(id1, priority=rule2.data.priority)
client.routing_rules.update(id2, priority=rule1.data.priority)

Best Practices

1. Update one field at a time when testing changes
2. Disable before major changes to prevent unexpected routing
3. Use descriptive names when renaming rules
4. Test priority changes by listing rules after update
5. Keep match conditions simple - complex logic can be split into multiple rules

Next Steps

• Delete Routing Rule
• Get Routing Rule
• List All Rules
• Create New Rule