Jira Attachment Size Limit: Cloud Defaults, Admin Limits, and Large File Handling

According to Atlassian's official administration documentation, Jira Cloud enforces a default attachment size limit of 1 GB per file, which administrators can adjust to an absolute ceiling of 2 GB per file. However, because Jira Cloud Free plans provide only 2 GB of total file storage per app and Standard plans cap total storage at 250 GB, storing raw build artifacts, video recordings, or memory dumps directly on issues quickly exhausts team storage quotas.

Engineering organizations frequently misjudge their file capacity because Jira exists in two distinct hosting architectures: Jira Cloud, managed by Atlassian, and Jira Data Center (along with legacy Jira Server), hosted on an organization's private servers or cloud infrastructure. Each platform applies different out-of-the-box defaults, administration controls, and storage ceilings.

Jira Cloud vs. Data Center Attachment Specifications

On Jira Cloud, Atlassian provides a generous single-file allowance out of the box. Every new Jira Cloud site defaults to 1 GB per attachment. Administrators can raise or lower this setting within Jira system administration, subject to an upper boundary of 2 GB (2,048 MB). Jira Cloud also limits each issue to 2,000 attachments, while overall account storage depends entirely on the Jira subscription tier.

On Jira Data Center and legacy Jira Server instances, Atlassian applies an out-of-the-box default of 10 MB (10,485,760 bytes) per file. This conservative baseline originated in earlier server eras to protect local application servers from memory exhaustion during multipart HTTP uploads. Data Center administrators can reconfigure this threshold up to 2,147,483,647 bytes, which Atlassian describes as 2 GB. Total storage capacity on Data Center is governed solely by the underlying file system, network-attached storage (NFS), or cloud block storage allocated to the server cluster.

Why Teams Frequently Assume a 100 MB Limit

A common search query among engineering teams centers on a perceived 100 MB Jira attachment limit. This confusion stems from four practical operational factors:

1. Confluence Cloud Default Settings: In organizations using both Jira and Confluence, users frequently mix up application boundaries. Confluence Cloud defaults to a 100 MB attachment limit. When team members collaborate across linked Jira issues and Confluence product requirement documents, they frequently assume Confluence's default attachment size limit applies to Jira issues as well.

2. Reverse Proxy and Gateway Caps: Many enterprise Data Center deployments front Jira with reverse proxies such as Nginx, Apache HTTP Server, Traefik, or AWS Application Load Balancers. Web servers frequently enforce default body size limits, such as Nginx default directives. If a reverse proxy drops an incoming multipart stream before the payload reaches the Jira application servlet, the browser surfaces an HTTP 413 error, leading users to believe Jira rejected the file.

3. Administrative Cost Controls: Because Jira Cloud Standard plans include 250 GB of file storage per app, some administrators lower the maximum attachment limit to preserve team allowances. This policy prevents a single developer from consuming significant account storage with raw crash dumps or video files.

4. Browser Document Preview Constraints: While Jira Cloud accepts attachments of 1 GB or 2 GB per file, inline previews are not always available for very large files or archive packages. Users attempting to inspect files inline may assume the upload failed when the issue shows a download prompt instead of a preview.

• Airtable Attachment Limits: File Sizes, Base Storage, and WorkaroundsThe Airtable attachment limit framework caps individual file uploads at 5 GB across all subscription tiers, while...
• AWS Bedrock File Size Limits: Document Constraints in Knowledge Bases and Converse APIAWS Bedrock Knowledge Bases enforces a 50 MB per-document limit for file ingestion, while the Bedrock Converse API caps...
• Excel File Size Limits: Documented Caps and Large Workbook WorkaroundsMicrosoft Excel enforces a 1,048,576 row cap per worksheet, Excel Online restricts browser editing to 100MB workbooks,...
• Notion File Upload Limits: Size Caps by Plan and Large-File WorkaroundsNotion limits individual file uploads to 5MB on the Free plan and provides unlimited file uploads with a 5GB maximum...
• AWS Lambda File Size Limits: Payload, Package, and Ephemeral Storage CapsAn AWS Lambda file size limit encompasses the execution constraints of AWS Lambda functions, specifically the 50MB...
• CSV File Size Limits: AI Assistant Upload Caps, Parsing Ceilings, and FixesCSV file size limits vary from strict row boundaries in spreadsheets to memory and token constraints in AI chat...

More on this subject: Agent File and Document Workflows (325 guides)

When project workflows require team members to attach build artifacts, design files, or diagnostic archives directly to issues, Jira administrators can increase the attachment limit through the administration console. Adjusting this setting requires global administrative permissions.

Adjusting Attachment Limits on Jira Cloud

On Jira Cloud, updating the attachment threshold requires the Administer Jira global permission. The change takes effect immediately across all projects in the site without restarting any services:

1. Select Settings (represented by the gear icon in the top-right navigation bar), then select System.
2. In the left navigation sidebar under the Advanced heading, select Attachments.
3. Select Edit Settings to display the Edit Attachment Settings dialog.
4. In the Attachment Size field, enter your desired maximum attachment threshold. Specify the target file threshold in megabytes or gigabytes, up to the maximum Jira Cloud attachment size limit of 2 GB.
5. (Optional) Set Enable ZIP Support to ON. This setting enables users to preview the individual file contents of uploaded ZIP archives directly from the issue view and allows team members to download all issue attachments at once as a single consolidated ZIP file.
6. Select Update to apply the configuration.

After updating attachment settings, verify your project permissions and screen configurations. Users must belong to a project role granted the Create Attachments permission in the associated permission scheme. If users need to remove outdated files, verify they hold the Delete Own Attachments permission. Also check that the Attachment field is visible within the field configuration associated with your project issue types.

Configuring Attachment Limits on Jira Data Center

On self-hosted Jira Data Center and Jira Server instances, administrators configure attachment limits through the System administration menu while ensuring underlying operating system and proxy parameters support larger payloads:

1. Navigate to Administration > System > Advanced > Attachments (this requires the Jira System Administrators global permission).
2. Select Edit Settings to open the configuration panel.
3. In the Attachment Size field, enter the new limit in bytes. On Jira Data Center, administrators enter the attachment size limit as an integer in bytes, where the maximum configurable limit is 2,147,483,647 bytes (2 GB).
4. Select Save to apply the new limit.

Synchronizing Web Servers and Reverse Proxies

Updating the setting inside Jira Data Center will not resolve upload failures if your front-end reverse proxy restricts incoming HTTP POST requests. If your organization routes traffic through Nginx, update the client_max_body_size directive in your site configuration file to match your Jira Data Center attachment threshold:

server {
    listen 443 ssl http2;
    server_name jira.example.com;
    client_max_body_size 2048m;
    location / {
        proxy_pass http://jira_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }
}

If you deploy Apache HTTP Server as a reverse proxy, set LimitRequestBody 2147483647 in your virtual host definition. In addition, review the maxPostSize attribute on the HTTP Connector in Jira's conf/server.xml file. Setting maxPostSize="-1" or maxPostSize="2147483647" prevents the embedded Tomcat container from truncating large multipart form submissions.

Increasing Jira attachment size limits to the 2 GB ceiling solves immediate upload rejections, but treating an issue tracker as a long-term binary storage repository introduces technical and financial friction across the software development lifecycle.

Rapid Depletion of Jira Cloud Storage Quotas

Jira Cloud plans link storage allowances to your licensing tier. The Free plan includes 2 GB of total file storage per app, while the Standard tier provides 250 GB of storage per app. Only Premium and Enterprise tiers remove overall account file storage limits.

Consider a mobile engineering team building iOS and Android applications. When developers attach compiled application archives, symbol packages, and automated UI test recordings across active sprints, accumulating large files rapidly depletes team storage allowances on Jira Cloud Standard plans. Over several development cycles, routine testing deliverables consume substantial portions of the available quota. Upgrading every user in the company to a Jira Cloud Premium plan simply to acquire additional file storage incurs substantial recurring licensing overhead across the entire organization.

Browser Upload Failures and Connection Drops

Standard web browsers interact with Jira via conventional HTTP POST multipart form uploads. When team members attempt to upload large memory dumps or multi-gigabyte screen recordings over standard office internet or home broadband, the upload process takes substantial time and remains vulnerable to network drops.

If the user experiences an intermittent Wi-Fi disconnection, an upstream routing glitch, or an operating system power-saving event that puts the network adapter to sleep, the TCP connection drops. Because a standard multipart upload is sent as a single request, a dropped connection aborts the transfer, and the engineer has to restart the upload from the beginning.

Backup Bloat and Performance Drag

In Jira Data Center, attachments live on the server file system in the jira-home/data/attachments directory. When tickets accumulate tens of thousands of large binary files, routine operations slow down:

• Disaster Recovery Snapshots: Cold backups and live storage volume replication take hours to complete when snapshots must process terabytes of old crash dumps and installation media.
• Issue Render Latency: Loading an issue containing dozens of large attachments forces the browser to fetch extensive attachment metadata, slowing page rendering times for team members reviewing ticket progress.
• Database and Index Overhead: Managing large attachment tables increases the size of Jira's database backups and complicates migrations between server instances or cloud tenants.

API Bottlenecks for Automated DevOps and Agents

Modern engineering teams increasingly rely on automated continuous integration pipelines, diagnostic bots, and AI ticket triage agents. When automated agents push diagnostic artifacts to Jira via the REST API (POST /rest/api/3/issue/{issueIdOrKey}/attachments), uploading massive multipart streams consumes runner memory and can run into gateway timeouts. When downstream AI agents analyze tickets, retrieving huge binary files to extract a few relevant log lines wastes network bandwidth and strains compute budgets.

When project assets exceed the 2 GB Jira attachment ceiling or threaten your subscription storage budget, engineering teams need dedicated strategies to separate ticket tracking from binary payload storage.

Manual File Splitting for Command-Line Workflows

If team members must attach an archive exceeding administrative limits and have no external repository configured, they can split the archive into multi-part segments using standard operating system utilities.

On macOS and Linux, compress and split a directory into segments smaller than 100 MB:

tar -czf - ./diagnostic_core_dump | split -b 95m - core_dump_part_

This command generates numbered segments such as core_dump_part_aa, core_dump_part_ab, and core_dump_part_ac. Each segment remains comfortably under restrictive Jira admin limits. To reassemble the archive after downloading all parts from the ticket, a colleague runs:

cat core_dump_part_* | tar -xzf -

On Windows systems, developers can achieve the same result using PowerShell or 7-Zip by selecting the Split to volumes option and specifying an appropriate archive volume size. While archive splitting works for occasional manual transfers, it introduces friction, clutters ticket comment histories, and requires manual assembly steps.

Decoupling Issue Tracking from Persistent Workspaces

A more sustainable architecture decouples Jira issue tracking from file persistence. Instead of uploading multi-gigabyte media assets, machine learning models, or raw logs directly to Jira issues, teams store assets in dedicated cloud storage and reference them within ticket descriptions.

Organizations frequently evaluate standard storage services like Amazon S3, Google Drive, or Box. While these services accept large files, they introduce distinct operational challenges:

• Amazon S3: Storing files in S3 buckets requires engineering teams to build custom presigned URL generators or manage IAM access policies for non-technical stakeholders. Presigned links expire (after seven days at most when signed with AWS Signature Version 4), leaving historical Jira tickets with broken download links.
• Generic Cloud Drives: Cloud drives like Google Drive or Dropbox keep file version history, but they are organized around individual user accounts and folders rather than project workspaces that agents and automated pipelines can search.

Fastio offers shared workspaces designed for engineering teams and AI agents. Instead of congesting Jira with raw binaries, teams create dedicated workspaces for project assets and builds. Monthly plans start with a 14-day free trial, which requires a credit card. Fastio provides three subscription tiers with dedicated storage allowances and generous upload limits:

Storing files in Fastio workspaces provides several advantages for Jira workflows:

• Per-File Version History: When QA engineers or automated build systems update a build package or log bundle, Fastio retains a complete per-file version history. Team members can inspect or restore earlier iterations without generating duplicate attachments on Jira tickets.
• Detailed Activity Logging: The platform records a detailed activity log of all workspace changes, including uploads, edits, moves, and deletions, giving project leads a clear record of modifications.
• Branded External Shares: When collaborating with external clients, security researchers, or contract developers, teams create branded shares with expiring links and per-recipient access controls. Shares can disable file downloads for confidential documents, protecting proprietary assets while keeping Jira tickets clean.
• Cloud Sync Integration: Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Teams can automatically ingest assets from existing corporate repositories without manual file transfers.

Manage large files outside Jira issue attachment limits

Store crash dumps, video recordings, and build artifacts in persistent workspaces with versioning, semantic search, and MCP connectivity for AI agents. Monthly plans start with a 14-day free trial.

Start 14-Day Trial

Automating ticket updates through continuous integration jobs and AI agents requires programmatic patterns that handle file size constraints gracefully. When build scripts or agents generate diagnostic files, code should inspect payload sizes and route files appropriately.

Programmatic Uploads via Jira REST API v3

When an automated script attaches a file directly to a Jira Cloud ticket, it submits a multipart POST request to the Jira issue attachment endpoint:

curl -D- \
  -u "user@example.com:${JIRA_API_TOKEN}" \
  -X POST \
  -H "X-Atlassian-Token: no-check" \
  -F "file=@./test_output.log" \
  https://your-company.atlassian.net/rest/api/3/issue/PROJ-1024/attachments

Notice the mandatory X-Atlassian-Token: no-check header. Jira Cloud rejects multipart API requests that omit this header to prevent cross-site request forgery (CSRF) vulnerabilities.

Before transmitting large payloads, client applications can query Jira's configured instance limits using the attachment metadata endpoint:

curl -s \
  -u "user@example.com:${JIRA_API_TOKEN}" \
  https://your-company.atlassian.net/rest/api/3/attachment/meta

The response returns a JSON payload detailing whether attachments are enabled and the maximum upload size in bytes:

{
  "enabled": true,
  "uploadLimit": 1073741824
}

Intelligent File Routing Script in Python

To prevent automated jobs from failing with HTTP 413 Payload Too Large errors, DevOps teams implement routing scripts that inspect file sizes before dispatching payloads. Teams typically offload oversized files to S3 buckets or managed workspaces. The example below hands large files to the Fastio CLI (fastio upload file):

import os
import subprocess
import requests

JIRA_DOMAIN = "https://your-company.atlassian.net"
JIRA_USER = "ci-bot@example.com"
JIRA_TOKEN = os.environ.get("JIRA_API_TOKEN")
FASTIO_WORKSPACE = "eng-builds"  # the fastio CLI reads FASTIO_API_KEY from the environment

MAX_JIRA_BYTES = 50 * 1024 * 1024  # Operational cap: 50 MB

def attach_or_link_artifact(issue_key: str, file_path: str):
    file_size = os.path.getsize(file_path)
    file_name = os.path.basename(file_path)
    if file_size <= MAX_JIRA_BYTES:
        url = f"{JIRA_DOMAIN}/rest/api/3/issue/{issue_key}/attachments"
        headers = {"X-Atlassian-Token": "no-check"}
        with open(file_path, "rb") as f:
            files = {"file": (file_name, f)}
            response = requests.post(url, headers=headers, auth=(JIRA_USER, JIRA_TOKEN), files=files)
        response.raise_for_status()
        print(f"Attached {file_name} directly to {issue_key}")
    else:
        print(f"{file_name} ({file_size} bytes) exceeds ticket limit; linking externally.")
        # The Fastio CLI handles chunked uploads for large files
        subprocess.run(
            ["fastio", "upload", "file", "--workspace", FASTIO_WORKSPACE, file_path],
            check=True,
        )
        comment_url = f"{JIRA_DOMAIN}/rest/api/3/issue/{issue_key}/comment"
        comment_body = {
            "body": {
                "type": "doc",
                "version": 1,
                "content": [
                    {
                        "type": "paragraph",
                        "content": [
                            {
                                "type": "text",
                                "text": f"Build artifact {file_name} stored in external engineering workspace."
                            }
                        ]
                    }
                ]
            }
        }
        requests.post(comment_url, auth=(JIRA_USER, JIRA_TOKEN), json=comment_body)

Enabling AI Agent Workflows with MCP

When teams deploy autonomous coding assistants or ticket triage bots (such as Claude Code, Cursor, or Codex), forcing an agent to parse a massive diagnostic log file attached to a Jira issue creates severe context window exhaustion. Large context loads degrade model reasoning and increase latency.

With Fastio Intelligence Mode enabled, files uploaded to a workspace undergo automatic background indexing for hybrid search (combining full-text, semantic, and metadata matching). Coding agents connect through the remote Model Context Protocol (MCP) server over Streamable HTTP:

• Coding Agents: In environments like Claude Code, Cursor, or Gemini CLI, developers configure https://mcp.fast.io/mcp/code in their client configuration.
• General Assistants and Claude Apps: Assistants connect to https://mcp.fast.io/mcp/tools. Setup instructions are documented at https://mcp.fast.io/docs.

Using MCP tools, an agent inspects linked diagnostic archives by calling search actions. Instead of ingesting an entire raw log archive into its prompt window, the agent retrieves only the specific stack traces, error messages, and configuration lines needed to diagnose the issue and draft a fix.

Managing file attachments effectively requires establishing clear security permissions, retention schedules, and access boundaries across engineering projects.

Configuring Attachment Permission Schemes

Jira controls attachment actions through project permission schemes. Administrators should regularly review these permissions so unauthorized users cannot upload unwanted files or remove primary evidence:

• Create Attachments: Governs whether a user or group can upload files to an issue. In public service desk projects or open customer portals, restrict this permission to validated customers to prevent malicious users from uploading spam or executable files.
• Delete Own Attachments: Permits users to delete files they uploaded personally. This is generally enabled for team members to allow cleaning up accidental uploads.
• Delete All Attachments: A high-privilege permission that allows users to delete any file attached to an issue regardless of who uploaded it. Restrict this permission to project administrators and lead engineers to maintain auditability.

Restricting Attachment Access with Issue Security Schemes

In Jira, issue permissions operate globally across the entire issue: if a user holds permission to browse an issue, that user can view and download all attachments on that issue. Jira does not offer per-attachment permission controls.

When an issue contains sensitive files such as customer financial data, security vulnerability reports, or confidential agreements, administrators must apply an Issue Security Scheme. Issue security levels restrict the entire ticket (including summary, comments, and attachments) to specific project roles, groups, or assigned users.

Establishing Storage Retention Policies

To prevent storage bloat and control subscription expenses on Jira Cloud, administrators should establish routine lifecycle maintenance:

1. Audit Large Issues via JQL: Use Jira Query Language (JQL) filters to identify issues holding heavy file loads. Queries such as attachments IS NOT EMPTY AND updated < -180d surface stale tickets with attached files.
2. Archive Closed Project Attachments: Before archiving completed projects or closing long-term epics, export primary project deliverables to a persistent cloud workspace and purge raw interim files from Jira.
3. Enforce External Links for Media Assets: Instruct product designers, QA testers, and video producers to share design prototypes and screen recordings through external workspace links rather than attaching raw video files to tickets.

By setting appropriate attachment size limits, aligning reverse proxies, and establishing persistent workspaces for large project files, engineering organizations keep their Jira instance fast, reliable, and cost-effective.