File size limits in Flask - Step-by-Step Execution

Concept Flow - File size limits

Start Flask app

↓

User uploads file

↓

Check file size <= limit?

No→Reject upload with error

Yes↓

Process and save file

↓

Send success response

The app starts, user uploads a file, the app checks if the file size is within the limit, rejects if too big, otherwise processes it.

Execution Sample

Flask

from flask import Flask, request
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024  # 2MB

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files.get('file')
    return 'File accepted' if file else ('No file', 400)

This Flask app limits uploads to 2MB and accepts a file from a POST request.

Execution Table

Step	Action	File Size (bytes)	Check Result	Outcome
1	User sends POST with file	1,500,000	1,500,000 <= 2,097,152	File accepted
2	User sends POST with file	2,500,000	2,500,000 <= 2,097,152	Upload rejected (413 error)
3	User sends POST without file	N/A	No file present	Upload rejected (400 error)

💡 Uploads stop when file size exceeds 2MB or no file is sent.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
file.size	N/A	1,500,000	N/A	N/A
MAX_CONTENT_LENGTH	2,097,152	2,097,152	2,097,152	2,097,152
upload_status	None	Accepted	Rejected	Rejected

Key Moments - 2 Insights

Why does the app reject the upload before reaching the route code when the file is too large?

Flask automatically rejects requests exceeding MAX_CONTENT_LENGTH with a 413 error before calling the route function, as shown in step 2 of the execution_table.

What happens if no file is included in the upload request?

The route function checks if 'file' exists in request.files; if not, it returns an error, as shown in step 3 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the outcome when the file size is 1,500,000 bytes?

A Upload rejected (400 error)

B File accepted

C Upload rejected (413 error)

D No file present

💡 Hint

Check row 1 in the execution_table under Outcome column.

At which step does the file size exceed the limit causing rejection?

A Step 2

B Step 1

C Step 3

D None

💡 Hint

Look at the Check Result column in the execution_table where file size is greater than MAX_CONTENT_LENGTH.

If MAX_CONTENT_LENGTH was increased to 3MB, what would happen at Step 2?

A Upload rejected (400 error)

B Upload rejected (413 error)

C File accepted

D No file present

💡 Hint

Refer to variable_tracker for MAX_CONTENT_LENGTH and compare with file.size at Step 2.

Concept Snapshot

Flask file size limits:
- Set MAX_CONTENT_LENGTH in app.config (bytes)
- Flask auto rejects requests exceeding limit with 413 error
- Check request.files for uploaded file
- Handle missing file cases
- Limits protect server from large uploads

Full Transcript

This visual trace shows how Flask handles file size limits during uploads. The app sets MAX_CONTENT_LENGTH to 2MB. When a user uploads a file, Flask checks the file size before running the route. If the file is larger than 2MB, Flask rejects the request with a 413 error automatically. If the file is smaller, the route processes it and returns acceptance. If no file is sent, the route returns an error. Variables like file.size and MAX_CONTENT_LENGTH track the size and limit. This prevents large files from overloading the server.

Practice

1. What does setting MAX_CONTENT_LENGTH in a Flask app do?

easy

A. Sets the maximum number of files a user can upload.

B. Limits the maximum size of incoming request data, like file uploads.

C. Defines the maximum number of users allowed to connect.

D. Controls the maximum time a request can take to process.

Solution

1. Step 1: Understand the role of MAX_CONTENT_LENGTH

   This setting defines the maximum size in bytes for incoming request data, such as file uploads.

2. Step 2: Identify what it limits

   It limits the size of the request body, preventing large uploads that could harm the app.

3. Final Answer:

   Limits the maximum size of incoming request data, like file uploads. -> Option B

4. Quick Check:

   MAX_CONTENT_LENGTH limits upload size [OK]

Hint: MAX_CONTENT_LENGTH sets max upload size in bytes [OK]

Common Mistakes:

• Confusing size limit with number of files
• Thinking it limits request time
• Assuming it controls user connections

2. Which of the following is the correct way to set a 2MB file size limit in Flask?

easy

A. app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024

B. app.MAX_CONTENT_LENGTH = 2 * 1024 * 1024

C. app.config.MAX_CONTENT_LENGTH = 2 * 1024 * 1024

D. app.set_config('MAX_CONTENT_LENGTH', 2 * 1024 * 1024)

Solution

1. Step 1: Recall Flask config syntax

   Flask config values are set using app.config dictionary syntax.

2. Step 2: Check each option

   app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 uses app.config['MAX_CONTENT_LENGTH'] correctly. Others use invalid syntax.

3. Final Answer:

   app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 -> Option A

4. Quick Check:

   Use app.config['KEY'] = value [OK]

Hint: Use app.config['KEY'] to set Flask config [OK]

Common Mistakes:

• Using dot notation instead of dictionary
• Calling non-existent set_config method
• Assigning config directly on app object

3. Given this Flask app code snippet, what happens if a user uploads a 3MB file?

app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    return 'File uploaded!'

medium

A. Flask automatically returns a 413 error and blocks the upload.

B. The upload succeeds and returns 'File uploaded!'

C. The app crashes with a runtime error.

D. The file is accepted but truncated to 2MB.

Solution

1. Step 1: Understand MAX_CONTENT_LENGTH effect on uploads

   Flask rejects requests exceeding this size with a 413 error automatically.

2. Step 2: Analyze the 3MB upload against 2MB limit

   3MB is larger than 2MB limit, so Flask blocks the request before reaching the route.

3. Final Answer:

   Flask automatically returns a 413 error and blocks the upload. -> Option A

4. Quick Check:

   Upload > MAX_CONTENT_LENGTH causes 413 error [OK]

Hint: Uploads over limit get 413 error automatically [OK]

Common Mistakes:

• Assuming upload succeeds anyway
• Thinking app crashes instead of 413 error
• Believing file is truncated silently

4. Identify the error in this Flask code that tries to limit upload size:

app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024

@app.route('/upload', methods=['POST'])
def upload():
    if request.content_length > app.config['MAX_CONTENT_LENGTH']:
        return 'File too large', 413
    file = request.files['file']
    return 'Upload successful'

medium

A. The route should allow GET method to upload files.

B. The content_length attribute does not exist on request.

C. The manual size check is unnecessary; Flask blocks large uploads automatically.

D. The MAX_CONTENT_LENGTH value must be set in bytes, not calculated.

Solution

1. Step 1: Recall Flask's built-in upload size handling

   Flask automatically returns a 413 error if upload exceeds MAX_CONTENT_LENGTH.

2. Step 2: Analyze the manual check in code

   The manual check duplicates Flask's behavior and is redundant.

3. Final Answer:

   The manual size check is unnecessary; Flask blocks large uploads automatically. -> Option C

4. Quick Check:

   Flask auto-blocks large uploads, no manual check needed [OK]

Hint: Flask auto-blocks large uploads; no manual check needed [OK]

Common Mistakes:

• Thinking content_length is missing
• Believing GET method is required for uploads
• Misunderstanding byte calculation for MAX_CONTENT_LENGTH

5. You want to allow file uploads up to 10MB but also want to show a custom error page instead of Flask's default 413 error. Which approach is best?

hard

A. Set MAX_CONTENT_LENGTH to 10MB and catch exceptions in the route to show custom error.

B. Remove MAX_CONTENT_LENGTH and manually check file size in the route.

C. Set MAX_CONTENT_LENGTH to 20MB and reject files over 10MB manually.

D. Set MAX_CONTENT_LENGTH to 10MB and add an error handler for 413 to show a custom page.

Solution

1. Step 1: Set MAX_CONTENT_LENGTH to desired limit

   Setting it to 10MB ensures Flask blocks uploads larger than this automatically.

2. Step 2: Add a Flask error handler for 413 errors

   Define a custom error handler to display a friendly message instead of default error.

3. Step 3: Avoid manual size checks or mismatched limits

   Manual checks or mismatched limits complicate logic and risk errors.

4. Final Answer:

   Set MAX_CONTENT_LENGTH to 10MB and add an error handler for 413 to show a custom page. -> Option D

5. Quick Check:

   Use MAX_CONTENT_LENGTH + 413 error handler for custom message [OK]

Hint: Use MAX_CONTENT_LENGTH + 413 error handler for custom message [OK]

Common Mistakes:

• Removing MAX_CONTENT_LENGTH and checking manually
• Setting limit higher than needed and manual rejection
• Catching exceptions instead of error handlers