HTTP

510 - Not Extended

Getting a 510 Not Extended means the server needs additional protocol extensions to process your request—the Require header lists extensions that must be included. This client-side error (4xx) happens when servers mandate specific HTTP extensions. Most common when servers require experimental or custom extensions, but also appears when protocol extensions are mandatory, extension negotiation fails, or servers enforce extension requirements.

#Common Causes

→Frontend: Missing Require header extensions. Protocol extensions not included in request. Client doesn't support required extensions. Extension headers missing or incorrect.
→Backend: Server requires specific protocol extensions. Extension validation middleware rejects requests. Server configuration mandates extensions. Extension negotiation fails.
→Infrastructure: API gateway enforces extension requirements. Load balancer requires extensions. Reverse proxy extension validation.

✓Solutions

1Step 1: Diagnose - Check DevTools Network tab Response headers—look for Require header listing needed extensions. Review which extensions are missing. Check extension format.
2Step 2: Diagnose - Server logs show which extensions are required. Review Require header in response. Check server extension configuration. Verify extension requirements.
3Step 3: Fix - Client-side: Add required extensions from Require header. Include extension headers in request. Update client to support extensions. Retry with extensions.
4Step 4: Fix - Server-side: Return 510 with Require header listing needed extensions. Provide clear extension documentation. Implement extension validation properly.
5Step 5: Fix - Infrastructure: Configure API gateway extension handling. Review load balancer extension requirements. Update reverse proxy extension support.

</>Code Examples

Fetch API: Handle 510 Extension Requirements

1// Client-side: Handle 510 by adding required extensions
2async function fetchWithExtensions() {
3  let response = await fetch('/api/endpoint', {
4    method: 'GET',
5    headers: {
6      'X-Protocol-Version': '1.0',
7    },
8  });
9  
10  if (response.status === 510) {
11    // Server requires extensions - check Require header
12    const requiredExtensions = response.headers.get('Require');
13    console.log('Required extensions:', requiredExtensions);
14    
15    // Parse and add required extensions
16    const extensions = requiredExtensions?.split(', ') || [];
17    const headers = { 
18      'X-Protocol-Version': '1.0',
19    };
20    
21    // Add required extensions
22    extensions.forEach(ext => {
23      const trimmed = ext.trim();
24      if (trimmed === 'feature-x') {
25        headers['X-Feature-X'] = 'enabled';
26      } else if (trimmed === 'feature-y') {
27        headers['X-Feature-Y'] = 'enabled';
28      } else if (trimmed === 'custom-auth') {
29        headers['X-Custom-Auth'] = 'token-value';
30      }
31    });
32    
33    // Retry with required extensions
34    response = await fetch('/api/endpoint', {
35      method: 'GET',
36      headers,
37    });
38  }
39  
40  if (!response.ok) {
41    throw new Error(`Request failed: ${response.status}`);
42  }
43  
44  return response.json();
45}
46
47// Automatic extension handling
48async function fetchWithAutoExtensions(url) {
49  const extensions = [];
50  let response = await fetch(url);
51  
52  // Retry with extensions if 510
53  while (response.status === 510) {
54    const required = response.headers.get('Require');
55    if (!required) break;
56    
57    const newExtensions = required.split(', ').map(e => e.trim());
58    extensions.push(...newExtensions);
59    
60    // Build headers with extensions
61    const headers = {};
62    newExtensions.forEach(ext => {
63      headers[`X-Extension-${ext}`] = 'enabled';
64    });
65    
66    response = await fetch(url, { headers });
67  }
68  
69  return response.json();
70}

Express.js: Return 510 with Required Extensions

1// Server-side: Return 510 with Require header
2const express = require('express');
3const app = express();
4
5// Extension requirement middleware
6const requireExtensions = (requiredExtensions) => {
7  return (req, res, next) => {
8    const providedExtensions = [];
9    
10    // Check for required extensions
11    requiredExtensions.forEach(ext => {
12      const headerName = `x-extension-${ext}`;
13      if (req.headers[headerName] || req.headers[headerName.replace(/-/g, '_')]) {
14        providedExtensions.push(ext);
15      }
16    });
17    
18    // Check if all required extensions are present
19    const missing = requiredExtensions.filter(ext => !providedExtensions.includes(ext));
20    
21    if (missing.length > 0) {
22      return res.status(510)
23        .set('Require', missing.join(', '))
24        .json({
25          error: 'Not Extended',
26          message: 'Additional extensions required',
27          requiredExtensions: missing,
28          providedExtensions: providedExtensions,
29        });
30    }
31    
32    next();
33  };
34};
35
36// Endpoint requiring extensions
37app.get('/api/secure', 
38  requireExtensions(['feature-x', 'custom-auth']),
39  (req, res) => {
40    res.json({ 
41      message: 'Access granted',
42      extensions: ['feature-x', 'custom-auth'],
43    });
44  }
45);
46
47// Extension validation
48app.use('/api/extended', (req, res, next) => {
49  const required = ['feature-x', 'feature-y'];
50  const provided = [];
51  
52  required.forEach(ext => {
53    if (req.headers[`x-extension-${ext}`]) {
54      provided.push(ext);
55    }
56  });
57  
58  if (provided.length < required.length) {
59    const missing = required.filter(ext => !provided.includes(ext));
60    return res.status(510)
61      .set('Require', missing.join(', '))
62      .json({
63        error: 'Not Extended',
64        requiredExtensions: missing,
65      });
66  }
67  
68  next();
69});

Nginx: Handle Extension Requirements

1# Nginx: Pass extension headers and handle 510
2server {
3    listen 80;
4    server_name api.example.com;
5    
6    location /api/extended/ {
7        # Pass extension headers to backend
8        proxy_pass http://backend;
9        proxy_set_header Host $host;
10        proxy_set_header X-Extension-Feature-X $http_x_extension_feature_x;
11        proxy_set_header X-Extension-Custom-Auth $http_x_extension_custom_auth;
12        
13        # Or pass all X-Extension-* headers
14        proxy_pass_request_headers on;
15        
16        # Backend will return 510 if extensions missing
17    }
18    
19    # Optional: Validate extensions at Nginx level
20    # location /api/secure/ {
21    #     if ($http_x_extension_feature_x = "") {
22    #         return 510 '{"error":"Not Extended","requiredExtensions":["feature-x"]}';
23    #         add_header Require "feature-x" always;
24    #         default_type application/json;
25    #     }
26    #     proxy_pass http://backend;
27    # }
28}

↗Related Errors

400 501

Provider Information

This error code is specific to HTTP services. For more information, refer to the official HTTP documentation.