Delete Firewall Rule

Delete Firewall Rule

Permanently deletes a firewall rule. This action cannot be undone.

Paid Plans Only

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

Caution

Deleted rules cannot be recovered. Consider disabling rules instead of deleting them if you might need them again.

Endpoint

DELETE /v1/firewall-rules/{id}

Path Parameters

Parameter	Type	Required	Description
id	integer	Yes	The firewall rule ID

Examples

TypeScript

import Tokenrouter from 'tokenrouter';

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

await client.firewallRules.delete(123);

console.log('Rule deleted successfully');

Python

from tokenrouter import Tokenrouter

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

client.firewall_rules.delete(123)

print("Rule deleted successfully")

cURL

curl -X DELETE https://api.tokenrouter.io/v1/firewall-rules/123 \
  -H "Authorization: Bearer tr_..."

Response

{
  "success": true
}

Error Responses

403 Forbidden - Free Plan

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

404 Not Found

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

Safe Deletion Pattern

Always verify before deleting:

TypeScript

// Get rule details first
const rule = await client.firewallRules.retrieve(ruleId);

console.log(`About to delete: ${rule.data.name}`);
console.log(`Priority: ${rule.data.priority}`);
console.log(`Action: ${rule.data.action}`);
console.log(`Pattern: ${rule.data.pattern}`);

// Confirm deletion
const confirmed = confirm('Delete this rule?');

if (confirmed) {
  await client.firewallRules.delete(ruleId);
  console.log('Rule deleted');
}

Python

# Get rule details first
rule = client.firewall_rules.retrieve(rule_id)

print(f"About to delete: {rule.data.name}")
print(f"Priority: {rule.data.priority}")
print(f"Action: {rule.data.action}")
print(f"Pattern: {rule.data.pattern}")

# Confirm deletion
confirmed = input("Delete this rule? (y/n): ").lower() == 'y'

if confirmed:
    client.firewall_rules.delete(rule_id)
    print("Rule deleted")

Bulk Deletion

Delete multiple rules:

TypeScript

// Delete all disabled rules
const rules = await client.firewallRules.list();

const disabledRules = rules.data.filter(r => !r.is_enabled);

console.log(`Found ${disabledRules.length} disabled rules to delete`);

for (const rule of disabledRules) {
  await client.firewallRules.delete(rule.id);
  console.log(`Deleted: ${rule.name}`);
}

Python

# Delete all disabled rules
rules = client.firewall_rules.list()

disabled_rules = [r for r in rules.data if not r.is_enabled]

print(f"Found {len(disabled_rules)} disabled rules to delete")

for rule in disabled_rules:
    client.firewall_rules.delete(rule.id)
    print(f"Deleted: {rule.name}")

Delete with Backup

Save rule configuration before deleting:

TypeScript

import fs from 'fs';

// Backup rule before deleting
const rule = await client.firewallRules.retrieve(ruleId);

const backup = {
  name: rule.data.name,
  priority: rule.data.priority,
  is_enabled: rule.data.is_enabled,
  scope: rule.data.scope,
  type: rule.data.type,
  pattern: rule.data.pattern,
  action: rule.data.action,
  replacement: rule.data.replacement,
  deleted_at: new Date().toISOString()
};

// Save backup to file
fs.appendFileSync(
  'firewall-deletions.json',
  JSON.stringify(backup) + '\n'
);

// Delete
await client.firewallRules.delete(ruleId);
console.log('Rule deleted and backed up');

Python

import json
from datetime import datetime

# Backup rule before deleting
rule = client.firewall_rules.retrieve(rule_id)

backup = {
    "name": rule.data.name,
    "priority": rule.data.priority,
    "is_enabled": rule.data.is_enabled,
    "scope": rule.data.scope,
    "type": rule.data.type,
    "pattern": rule.data.pattern,
    "action": rule.data.action,
    "replacement": rule.data.replacement,
    "deleted_at": datetime.now().isoformat()
}

# Save backup to file
with open("firewall-deletions.json", "a") as f:
    f.write(json.dumps(backup) + "\n")

# Delete
client.firewall_rules.delete(rule_id)
print("Rule deleted and backed up")

Alternative: Disable Instead

Consider disabling rules instead of deleting:

TypeScript

// Instead of deleting, disable the rule
await client.firewallRules.update(ruleId, {
  is_enabled: false
});

// Can be re-enabled later if needed
await client.firewallRules.update(ruleId, {
  is_enabled: true
});

Python

# Instead of deleting, disable the rule
client.firewall_rules.update(rule_id, is_enabled=False)

# Can be re-enabled later if needed
client.firewall_rules.update(rule_id, is_enabled=True)

When to Delete vs Disable

Scenario	Recommendation
Testing a rule	Disable it
Seasonal pattern (e.g., holiday-specific)	Disable it
Temporary relaxation of rules	Disable it
Deprecated pattern no longer needed	Delete it
Duplicate rule	Delete it
Incorrect rule that never worked	Delete it
Rule with security vulnerabilities	Delete it

Cleanup Strategies

Remove Old Unused Rules

TypeScript

const rules = await client.firewallRules.list();

const now = new Date();
const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);

for (const rule of rules.data) {
  const updated = new Date(rule.updated_at);

  if (!rule.is_enabled && updated < ninetyDaysAgo) {
    console.log(`Deleting old rule: ${rule.name} (last updated ${updated.toLocaleDateString()})`);
    await client.firewallRules.delete(rule.id);
  }
}

Python

from datetime import datetime, timedelta

rules = client.firewall_rules.list()

now = datetime.now()
ninety_days_ago = now - timedelta(days=90)

for rule in rules.data:
    updated = datetime.fromisoformat(rule.updated_at.replace('Z', '+00:00'))

    if not rule.is_enabled and updated < ninety_days_ago:
        print(f"Deleting old rule: {rule.name} (last updated {updated.date()})")
        client.firewall_rules.delete(rule.id)

Remove Warn-Only Rules

TypeScript

// Delete all warn-action rules (if moving to logging)
const rules = await client.firewallRules.list();

const warnRules = rules.data.filter(r => r.action === 'warn');

console.log(`Removing ${warnRules.length} warn-only rules`);

for (const rule of warnRules) {
  await client.firewallRules.delete(rule.id);
}

Python

# Delete all warn-action rules (if moving to logging)
rules = client.firewall_rules.list()

warn_rules = [r for r in rules.data if r.action == "warn"]

print(f"Removing {len(warn_rules)} warn-only rules")

for rule in warn_rules:
    client.firewall_rules.delete(rule.id)

Best Practices

1. Always get rule details before deleting
2. Backup critical rules before deletion
3. Prefer disabling over deleting when unsure
4. Delete in batches carefully to avoid accidents
5. Document deletion reasons in change log
6. Test after deletion to ensure no unexpected behavior
7. Review dependencies - check if other systems reference the rule

Recovery

If you accidentally deleted a rule and have a backup:

TypeScript

// Recreate from backup
const backup = {
  name: "Block Credit Cards",
  priority: 100,
  is_enabled: true,
  scope: "prompt",
  type: "regex",
  pattern: "\\d{16}",
  action: "block",
  replacement: null
};

const restored = await client.firewallRules.create(backup);
console.log(`Restored rule: ${restored.data.id}`);

Python

# Recreate from backup
backup = {
    "name": "Block Credit Cards",
    "priority": 100,
    "is_enabled": True,
    "scope": "prompt",
    "type": "regex",
    "pattern": r"\d{16}",
    "action": "block",
    "replacement": None
}

restored = client.firewall_rules.create(**backup)
print(f"Restored rule: {restored.data.id}")

Next Steps

• Create Firewall Rule
• Update Firewall Rule
• List All Rules
• Firewall API Overview