HTTP

507 - Insufficient Storage

Getting a 507 Insufficient Storage means the server ran out of disk space or hit storage quotas—the file system is full, storage quota exceeded, or there's no room to save uploaded files or generated data. This server-side error (5xx) happens when servers can't write data due to storage limits. Most common during large file uploads when disk space is exhausted, but also appears when log files fill up the disk, database storage quotas are reached, or temporary file storage runs out.

#Common Causes

→Frontend: Client can't fix 507s directly, but reducing upload sizes helps. Large file uploads fail when server storage is full. No retry logic means users see errors.
→Backend: Disk space exhausted (df -h shows 100% usage). Storage quota exceeded (user/application quotas). Log files filling up disk (unrotated logs). Database storage limits reached. Temporary file storage full.
→Infrastructure: Container storage limits exceeded. Volume mounts full. Cloud storage quotas reached. Backup storage consuming space. File system corruption preventing writes.

✓Solutions

1Step 1: Diagnose - Check server disk usage (df -h, du -sh). Review storage quotas in cloud console. Check log file sizes (find /var/log -size +100M). Review database storage usage. Check container storage limits.
2Step 2: Diagnose - Server logs show "No space left on device" errors. Review which directories are consuming space. Check for large temporary files. Examine backup storage usage.
3Step 3: Fix - Client-side: Reduce file upload sizes. Compress files before uploading. Implement chunked uploads. Show user-friendly error messages. Retry with smaller files.
4Step 4: Fix - Server-side: Free up disk space (delete old logs, temporary files). Implement log rotation. Increase storage quotas. Clean up old database records. Implement storage monitoring and alerts.
5Step 5: Fix - Infrastructure: Increase container storage limits. Expand volume sizes. Request cloud storage quota increases. Configure automatic log rotation. Set up storage monitoring.

</>Code Examples

Fetch API: Handle Storage Errors

1// Client-side: Handle 507 with user feedback
2async function uploadFile(file) {
3  // Check file size before upload
4  const maxFileSize = 100 * 1024 * 1024; // 100MB
5  if (file.size > maxFileSize) {
6    throw new Error('File too large. Maximum size is 100MB.');
7  }
8  
9  const formData = new FormData();
10  formData.append('file', file);
11  
12  try {
13  const response = await fetch('/api/upload', {
14    method: 'POST',
15      body: formData,
16  });
17  
18  if (response.status === 507) {
19      const error = await response.json();
20      showUserMessage({
21        type: 'error',
22        title: 'Storage Full',
23        message: 'Server storage is full. Please try again later or contact support.',
24      });
25      throw new Error('Insufficient storage on server');
26    }
27    
28    if (!response.ok) {
29      throw new Error(`Upload failed: ${response.status}`);
30    }
31    
32    return await response.json();
33  } catch (error) {
34    console.error('Upload error:', error);
35    throw error;
36  }
37}
38
39// Check storage availability before upload
40async function checkStorageAvailability() {
41  try {
42    const response = await fetch('/api/storage/info');
43    const { available, total, used } = await response.json();
44    
45    if (available < 1024 * 1024) { // Less than 1MB
46      console.warn('Server storage is running low');
47      return false;
48    }
49    
50    return true;
51  } catch (error) {
52    console.error('Failed to check storage:', error);
53    return true; // Assume available if check fails
54  }
55}

Express.js: Storage Monitoring and Limits

1// Server-side: Monitor storage and handle 507 errors
2const express = require('express');
3const fs = require('fs');
4const path = require('path');
5const app = express();
6const multer = require('multer');
7
8// Check disk space
9function checkDiskSpace(dir) {
10  try {
11    const stats = fs.statfsSync(dir);
12    const freeBytes = stats.bavail * stats.bsize;
13    const totalBytes = stats.blocks * stats.bsize;
14    const usedBytes = totalBytes - freeBytes;
15    const freePercent = (freeBytes / totalBytes) * 100;
16    
17    return {
18      free: freeBytes,
19      total: totalBytes,
20      used: usedBytes,
21      freePercent: freePercent,
22    };
23  } catch (error) {
24    console.error('Failed to check disk space:', error);
25    return null;
26  }
27}
28
29// Storage check middleware
30const checkStorage = (req, res, next) => {
31  const uploadDir = path.join(__dirname, 'uploads');
32  const storage = checkDiskSpace(uploadDir);
33  
34  if (!storage) {
35    return res.status(500).json({ error: 'Failed to check storage' });
36  }
37  
38  // Warn if less than 10% free
39  if (storage.freePercent < 10) {
40    console.warn(`Low disk space: ${storage.freePercent.toFixed(2)}% free`);
41  }
42  
43  // Reject if less than 1% free
44  if (storage.freePercent < 1) {
45    return res.status(507).json({
46      error: 'Insufficient Storage',
47      message: 'Server storage is full. Please try again later.',
48      storage: {
49        free: storage.free,
50        freePercent: storage.freePercent.toFixed(2),
51      },
52    });
53  }
54  
55  req.storageInfo = storage;
56  next();
57};
58
59// Configure multer with storage limits
60const upload = multer({
61  dest: 'uploads/',
62  limits: {
63    fileSize: 100 * 1024 * 1024, // 100MB
64  },
65  fileFilter: (req, file, cb) => {
66    // Check storage before accepting file
67    const storage = checkDiskSpace('uploads/');
68    if (storage && storage.freePercent < 1) {
69      cb(new Error('Insufficient storage'));
70    } else {
71      cb(null, true);
72    }
73  },
74});
75
76// Upload endpoint with storage check
77app.post('/api/upload', checkStorage, upload.single('file'), (req, res) => {
78  if (!req.file) {
79    return res.status(400).json({ error: 'No file uploaded' });
80  }
81  
82  res.json({
83    success: true,
84    filename: req.file.filename,
85    size: req.file.size,
86    storage: req.storageInfo,
87  });
88});
89
90// Storage info endpoint
91app.get('/api/storage/info', (req, res) => {
92  const storage = checkDiskSpace('uploads/');
93  if (!storage) {
94    return res.status(500).json({ error: 'Failed to check storage' });
95  }
96  
97  res.json({
98    available: storage.free,
99    total: storage.total,
100    used: storage.used,
101    freePercent: storage.freePercent.toFixed(2),
102  });
103});

Nginx: Storage and File Upload Limits

1# Nginx: Configure file upload limits and storage monitoring
2server {
3    listen 80;
4    server_name api.example.com;
5    
6    # Limit request body size (prevents filling disk)
7    client_max_body_size 100M;
8    
9    # Buffer settings
10    client_body_buffer_size 128k;
11    client_body_temp_path /var/cache/nginx/client_temp;
12    
13    location /api/upload {
14        # Check if temp directory has space
15        # (Nginx doesn't directly check disk space, but limits help)
16        
17        proxy_pass http://backend;
18        proxy_set_header Host $host;
19        proxy_set_header X-Real-IP $remote_addr;
20        
21        # Increase timeouts for large uploads
22        proxy_read_timeout 300s;
23        proxy_send_timeout 300s;
24        
25        # Don't buffer large uploads
26        proxy_request_buffering off;
27    }
28    
29    # Error page for 413 (Payload Too Large) - related to storage
30    error_page 413 /413.html;
31    location = /413.html {
32        return 413 '{"error":"Payload Too Large","message":"File size exceeds maximum allowed size"}';
33        default_type application/json;
34    }
35}
36
37# Monitor disk space with external script
38# Add to crontab: */5 * * * * /usr/local/bin/check-disk-space.sh
39# Script should alert if disk usage > 90%

↗Related Errors

413 503

Provider Information

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