OJS File Upload Not Working: Causes and How to Fix It

Authors Are Submitting, but Their Files Are Not Going Through

Your OJS journal is live. Your submission form is configured. Authors are finding your journal and starting the submission process. But somewhere in the file upload step, when they try to attach their manuscript, their figures, or their supplementary files, the upload fails.

Sometimes it fails silently. The progress bar fills up and then nothing happens. Sometimes it returns a vague error message. Sometimes it works for small files but fails for anything over a certain size. Sometimes it fails only for specific file types. And sometimes it works for authors but fails when editors try to upload galley files or revision requests.

The OJS file upload not working problem disrupts your journal at its most critical point, and the submission workflow. Authors who can't upload their manuscripts don't submit. Authors who hit an error during submission often don't try again. Every failed upload is a potential submission your journal never receives.

This guide covers every known cause of OJS file upload failures, how to diagnose which one is affecting your installation, and the exact steps to fix each one, written by OJS specialists who have resolved file upload problems across hundreds of installations in 20+ countries.

If your submission workflow is broken right now and you need it fixed fast, visit ojsguru.com for priority OJS support.

How OJS Handles File Uploads: The Basics

Before going into causes and fixes, it helps to understand how OJS processes file uploads.

When an author uploads a manuscript, OJS does several things at once:

Receiving the file, and the web server accepts the uploaded file through PHP and stores it temporarily in PHP's upload temp directory.

Validating the file, OJS checks the file type against your configured submission file types and checks the file size against PHP and server limits.

Moving the file, OJS moves the validated file from the PHP temp directory to your OJS files directory, the permanent storage location defined in config.inc.php.

Recording the file, OJS writes the file metadata (name, type, size, uploader, submission ID) to the database.

A failure at any of these four stages produces a file upload error. The stage where it fails determines the cause, and the fix. Most file upload failures happen at stage one (PHP limits) or stage three (file directory permissions or configuration).

Step 1: Identify Where the Upload Is Failing

Before applying any fix, gather this information:

What exactly happens when the upload fails? Does the progress bar appear and stall? Does it complete but show no file attached? Does an error message appear, and if so, what does it say exactly?

What file size triggers the failure? Try uploading a very small file (under 1MB). If that works but larger files fail, the problem is almost certainly a file size limit.

What file types fail? If PDF uploads work but DOCX fails, or vice versa, the problem may be a MIME type configuration issue.

Who is affected? Does the failure happen for authors during submission, for editors uploading galleys, or for both? Role-specific failures narrow the cause.

Check your OJS error log:

/path-to-your-ojs/cache/logs/errors.log

Check your server PHP error log:

# Ubuntu/Debian
sudo tail -100 /var/log/apache2/error.log

# CentOS/RHEL
sudo tail -100 /var/log/httpd/error_log

The error log almost always contains the specific reason for the upload failure, even when OJS shows only a generic error to the user.

Cause 1: PHP File Upload Size Limits Too Low

This is the most common cause of OJS file upload failures. PHP has two settings that control the maximum size of uploaded files, and both must be set high enough to accommodate your journal's manuscript files. If either setting is too low, uploads that exceed the limit will fail silently or return a generic error.

The two PHP settings you need to know:

upload_max_filesize, the maximum size of a single uploaded file post_max_size, the maximum size of all data in a single POST request (must be larger than upload_max_filesize)

Default values on most servers:

upload_max_filesize = 2M
post_max_size = 8M

A 2MB limit will block the vast majority of academic manuscript submissions. A typical Word document with figures runs 5MB to 20MB. A PDF with high-resolution images can easily exceed 50MB.

How to identify this cause:

Large file uploads fail while small ones succeed. Your PHP error log shows Uploaded file exceeds the upload_max_filesize directive or POST Content-Length exceeds the limit.

How to fix it:

Option A, Edit php.ini directly (VPS/dedicated server):

sudo nano /etc/php/8.1/apache2/php.ini

# Update these values
upload_max_filesize = 50M
post_max_size = 55M
max_execution_time = 300
max_input_time = 300

sudo systemctl restart apache2

Option B, Add to .htaccess (shared hosting):

php_value upload_max_filesize 50M
php_value post_max_size 55M
php_value max_execution_time 300
php_value max_input_time 300

Option C, Add to OJS .user.ini (some hosting environments):

upload_max_filesize = 50M
post_max_size = 55M

Important:post_max_size must always be larger than upload_max_filesize, set it at least 5MB higher. If post_max_size is smaller, uploads will fail even when the file itself is within upload_max_filesize.

After making changes, verify the new limits are active:

php -r "echo ini_get('upload_max_filesize');"

Then clear OJS cache and test a large file upload.

Cause 2: OJS Files Directory Not Configured or Not Writable

OJS stores all uploaded files, manuscripts, galleys, review files, supplementary materials, in a dedicated files directory defined in config.inc.php. If this directory doesn't exist, is in the wrong location, or doesn't have the correct write permissions for the web server, every file upload will fail.

How to identify this cause:

Your error log shows Unable to create directory, Permission denied, Failed to move uploaded file, or files_dir is not writable.

How to fix it:

Step 1, Check your files directory configuration:

Open config.inc.php and find:

files_dir = /path-to-your-files-directory

This path should point to a directory that:

• Exists on the server
• Is outside your web root (for security, files should not be directly accessible via browser)
• Is writable by the web server user

Step 2, Create the directory if it doesn't exist:

sudo mkdir -p /var/ojs-files

Step 3, Set correct ownership and permissions:

# Set ownership to web server user (www-data on Ubuntu, apache on CentOS)
sudo chown -R www-data:www-data /var/ojs-files

# Set permissions
sudo chmod -R 775 /var/ojs-files

Step 4, Verify the path in config.inc.php is correct:

; Use absolute path,  not relative
files_dir = /var/ojs-files

Do not use a relative path for files_dir. Always use the full absolute path from the server root.

Step 5, Test write permissions:

# Test that the web server can write to the directory
sudo -u www-data touch /var/ojs-files/test.txt
ls /var/ojs-files/
sudo rm /var/ojs-files/test.txt

If this command succeeds, the web server can write to the directory and file uploads should work.

Cause 3: PHP Temp Directory Not Writable

Before OJS moves an uploaded file to its permanent storage location, PHP holds the file temporarily in its upload temp directory. If this temp directory is not writable by the web server, PHP cannot receive the file in the first place, and the upload fails before OJS even sees it.

How to identify this cause:

Your PHP error log shows move_uploaded_file() failed, Unable to move temporary file, or open_basedir restriction in effect. Small and large files both fail equally.

How to fix it:

Check the current PHP temp directory:

php -r "echo sys_get_temp_dir();"

Verify it's writable:

ls -la /tmp
# Should show write permissions for the web server user

Fix permissions:

sudo chmod 1777 /tmp

Or configure a custom temp directory:

In php.ini:

upload_tmp_dir = /var/php-tmp

Then create and permission the directory:

sudo mkdir /var/php-tmp
sudo chown www-data:www-data /var/php-tmp
sudo chmod 775 /var/php-tmp

If open_basedir is restricting access:

On some shared hosting environments, open_basedir is configured to prevent PHP from accessing directories outside a specific path. Contact your hosting provider to either add your temp directory to the open_basedir whitelist or configure a temp directory within the allowed path.

Cause 4: Incorrect File Type Configuration in OJS

OJS allows journal managers to configure which file types are accepted during submission. If the allowed file types list is too restrictive, or if the MIME type for a common format like PDF or DOCX is missing, authors will receive a file type rejection error when uploading valid manuscripts.

How to identify this cause:

The upload fails with a message like This file type is not allowed or Invalid file type. Small and large files of the same type both fail. Files of a different type upload successfully.

How to fix it:

Go to Workflow Settings → Submission → Submission File Types in your OJS admin panel.

Ensure these common MIME types are included in your allowed file list:

Add any missing MIME types that your journal accepts and save. Test the upload immediately after saving.

Also check: Some OJS versions have a separate file type configuration under Website Settings → Uploads. Verify both locations if the problem persists after updating submission file types.

Cause 5: Server-Level File Size or Request Limits

Beyond PHP's own limits, your web server, Apache or Nginx, including has its own request size limits. If a file upload exceeds these server-level limits, the server rejects the request before PHP even processes it, and the upload fails with no useful error message shown to the user.

How to identify this cause:

Large file uploads return a 413 Request Entity Too Large error in the browser. Or the upload fails with no message at all and your server error log shows client intended to send too large a body.

How to fix it for Apache:

Add to your Apache VirtualHost configuration or .htaccess:

LimitRequestBody 104857600

This sets the limit to 100MB (104857600 bytes). Adjust to match your needs.

How to fix it for Nginx:

Add to your Nginx server block:

client_max_body_size 100M;

Then restart Nginx:

sudo systemctl restart nginx

For Cloudflare users:

Cloudflare's free plan limits upload sizes to 100MB. If your journal accepts large supplementary data files that exceed this, you'll need a Cloudflare paid plan or you'll need to bypass Cloudflare for upload requests.

Cause 6: JavaScript Error Preventing Upload Interface From Working

OJS uses JavaScript to handle the file upload interface, the drag-and-drop zone, the progress bar, and the file attachment confirmation. If a JavaScript error occurs on the submission page, the upload interface may appear but not function, clicks do nothing, drag-and-drop doesn't work, and no file ever gets sent to the server.

How to identify this cause:

The upload interface appears but clicking the upload button or dragging files does nothing at all. No network request is made. Opening your browser's developer tools console (F12) shows JavaScript errors on the page.

How to fix it:

Step 1, Check browser console for errors: Press F12, go to the Console tab, and attempt the upload. Note any red error messages.

Step 2, Clear OJS cache: JavaScript files are cached by OJS. After any upgrade or plugin change, stale cached JS files can cause interface failures.

rm -rf /path-to-ojs/cache/fc/*
rm -rf /path-to-ojs/cache/t_cache/*

Step 3, Check for plugin conflicts: Third-party plugins that add custom JavaScript to OJS pages can conflict with OJS's core upload scripts. Disable recently installed plugins and retest.

Step 4, Check browser compatibility: OJS 3.x requires a modern browser. Very old browsers (Internet Explorer, outdated Chrome or Firefox) may not support OJS's JavaScript upload interface. Ask affected users to try an updated browser.

Step 5, Check Content Security Policy headers: If your server sends restrictive Content Security Policy headers, they may block OJS's upload scripts from running. Check your Nginx or Apache configuration for CSP headers and ensure they allow OJS's own scripts.

Cause 7: Submission File Stage Misconfiguration

In OJS 3.x, file uploads are tied to specific submission workflow stages, submission files, review files, revision files, and production galleys each have their own upload configuration. If the submission stage is misconfigured, missing required file stages or having incorrect stage assignments, and the upload interface may fail silently when authors try to attach files.

How to identify this cause:

The upload interface loads but after selecting a file, the submission stage dropdown is empty or shows no valid options. The upload appears to process but no file is attached to the submission record. This problem often affects specific workflow stages while others work normally.

How to fix it:

Go to Workflow Settings → Submission in your OJS admin panel and verify:

• Submission file types are configured for the submission stage
• Each active submission stage has at least one file type assigned
• The workflow stages are in the correct order (submission, review, copyediting, production)

Also check Workflow Settings → Review and confirm:

• Revision file uploads are enabled for the revision stage
• Reviewer file uploads are configured if you use blind review with file attachments

If stages appear missing or incorrectly ordered, resave your workflow settings, sometimes OJS workflow stage configurations become inconsistent after an upgrade and a resave rebuilds them correctly.

Cause 8: Disk Space Exhausted on Server

When your server's disk partition runs out of space, file uploads fail immediately, PHP cannot write to the temp directory, OJS cannot move files to the files directory, and every upload attempt returns an error. This is more common than most editors expect, particularly on VPS servers with limited storage or journals that accumulate years of submission files without cleanup.

How to identify this cause:

Your error log shows No space left on device or disk quota exceeded. All file uploads fail regardless of file size or type.

How to check disk space:

df -h

Look for any partition at or near 100% usage. The partition containing your OJS files directory and PHP temp directory are the critical ones.

How to fix it:

Immediate fix, free up space:

# Find large files consuming space
sudo du -sh /* | sort -rh | head -20

# Clear old log files
sudo truncate -s 0 /var/log/apache2/access.log

# Clear old OJS cache
rm -rf /path-to-ojs/cache/fc/*

# Clear old PHP session files
sudo find /tmp -name "sess_*" -mtime +7 -delete

Long-term fix:

• Upgrade your VPS storage plan
• Move your OJS files directory to a larger storage volume or cloud storage
• Implement a regular cleanup policy for old submission files that are no longer needed

Cause 9: Antivirus or Security Software Blocking Uploads

Some server environments, particularly those managed by university IT departments, have antivirus or web application firewall (WAF) software that scans uploaded files in real time. If this software flags an uploaded file as suspicious, it can block the upload silently or return a confusing error message that has nothing to do with OJS's own configuration.

How to identify this cause:

File uploads fail inconsistently, some files upload successfully while others of the same type and similar size fail. The failures don't correlate with file size or type. Your hosting provider or IT department has server-level security software installed.

How to fix it:

Contact your hosting provider or IT department and:

• Ask whether a WAF or antivirus is scanning file uploads on your server
• Request that the OJS files directory and upload path be whitelisted
• Ask for the security software's logs to identify which files are being blocked and why

If you're using a WAF like ModSecurity on Apache, check its audit log:

sudo tail -100 /var/log/apache2/modsec_audit.log

Look for entries corresponding to the time of failed uploads. ModSecurity rule IDs in the log can help identify which rule is blocking the upload and whether it can be safely disabled for your OJS path.

Quick Diagnostic Checklist

Work through this in order before attempting any fix:

• Try uploading a very small file (under 1MB): does it succeed?
• Try uploading different file types, does the failure affect all types or specific ones?
• Check OJS error log at /cache/logs/errors.log
• Check PHP error log for upload-related errors
• Check current PHP upload_max_filesize and post_max_size values
• Verify files_dir in config.inc.php exists and is writable
• Check server disk space with df -h
• Open browser developer tools console during upload, any JavaScript errors?
• Test in a different browser
• Disable recently installed plugins and retest
• Check for 413 errors in browser, indicates server-level size limit
• Verify submission file types are configured in OJS workflow settings

Recommended File Upload Configuration for Production OJS Journals

After working with hundreds of OJS installations, here is the configuration we recommend for a stable, fully functional file upload system:

PHP settings:

upload_max_filesize = 50M
post_max_size = 55M
max_execution_time = 300
max_input_time = 300
memory_limit = 256M

Web server settings (Nginx example):

client_max_body_size 55M;
client_body_timeout 300s;

Web server settings (Apache example):

LimitRequestBody 57671680

OJS files directory:

; Absolute path, outside web root, writable by web server
files_dir = /var/ojs-files

Accepted MIME types in OJS: Configure at minimum: PDF, DOCX, DOC, RTF, ZIP, JPEG, PNG, TIFF

These settings accommodate manuscripts, figures, supplementary data files, and galley files for the vast majority of research journals without hitting size limits or permission errors.

When to Call in a Professional

File upload problems in OJS are almost always fixable by working through the checklist above. But some situations call for professional help:

• Your submission workflow has been broken for days and authors are sending emails about failed submissions
• You don't have server access to check PHP settings or file directory permissions
• The problem appeared after a server migration and multiple configuration files may need updating
• You've worked through the checklist and uploads still fail with no clear error
• Your journal is hosted on a university server managed by IT and you can't make configuration changes yourself

OJS Guru configures and fixes OJS file upload systems as a standard service. We handle the full diagnosis, PHP limits, directory permissions, server configuration, and OJS workflow settings, so your authors can submit without hitting errors.

👉 Get a free consultation at ojsguru.com

Preventing OJS File Upload Problems Going Forward

Set PHP limits correctly from day one. The default PHP upload limits are far too low for academic publishing. Every new OJS installation should have upload_max_filesize set to at least 50MB before accepting any submissions.

Keep your files directory outside the web root. This is both a security requirement and a stability practice. Files stored inside the web root are vulnerable to direct access and are more likely to be affected by web server configuration changes.

Monitor disk space regularly. Set up a simple disk space alert on your server, most hosting control panels offer this. Getting an alert at 80% full gives you time to act before uploads start failing at 100%.

Test file uploads after every upgrade. Make testing the full submission workflow, including a file upload, part of your standard post-upgrade checklist. Catching an upload problem immediately after an upgrade makes the cause obvious and the fix fast.

Document your file configuration. Keep a record of your files_dir path, your PHP upload limits, and your server upload limits. When something changes, you can verify quickly whether the configuration still matches your requirements.

Summary

OJS file upload not working is always caused by something specific and fixable at the server, PHP, or OJS configuration level. The nine causes covered in this guide account for the vast majority of file upload failures in production OJS journals:

1. PHP file upload size limits too low
2. OJS files directory not configured or not writable
3. PHP temp directory not writable
4. Incorrect file type configuration in OJS
5. Server-level file size or request limits
6. JavaScript error preventing upload interface from working
7. Submission file stage misconfiguration
8. Disk space exhausted on server
9. Antivirus or security software blocking uploads

Work through the diagnostic checklist, identify your specific cause, and apply the relevant fix. In most cases the problem is a PHP limit or a directory permission issue, both of which are straightforward to correct once identified.

If your submission workflow is broken and authors are failing to submit, contact OJS Guru at ojsguru.com. We fix OJS file upload problems every day and we'll have your submission workflow running correctly.

OJS Guru is a professional Open Journal Systems service provider specializing in OJS installation, customization, migration, and technical support for research journal publishers in 20+ countries. Visit ojsguru.com to request a free consultation.