How to Access Jira Database

If you’ve ever needed to pull raw data out of Jira — for reporting, auditing, or integration — you already know the default UI gets in your way fast.

The built-in filters only go so far. Dashboards don’t tell the full story. And when stakeholders want custom reports, you’re either exporting CSVs manually or digging for a better way.

This guide shows you exactly how to access the Jira database — whether you’re on Jira Server, Data Center, or Cloud — using the right tools at the right time.

What “Accessing the Jira Database” Actually Means

Before jumping into methods, let’s be clear on what you’re trying to do.

Jira stores all its data — issues, projects, users, workflows, comments, transitions — in a relational database. Depending on your deployment, that database is either:

• PostgreSQL (most common for self-managed)
• MySQL or MS SQL Server (older or enterprise deployments)
• Oracle (legacy enterprise)
• Cloud-managed (Atlassian controls this entirely on Jira Cloud)

According to Atlassian’s own documentation, over 65% of Jira Data Center deployments use PostgreSQL as their primary backend. If you’re on Jira Server or Data Center, you have direct SQL access. If you’re on Cloud, you work through APIs.

Understanding which environment you’re in changes everything about your approach.

Why Teams Need Direct Database Access

The Jira UI is built for project management — not data extraction.

Here’s what teams consistently run into:

• Jira Query Language (JQL) has limits. Complex cross-project aggregations, historical trend data, and custom field joins require something more powerful.
• Built-in reports don’t scale. Atlassian reports that teams managing 50+ projects inside Jira routinely hit performance ceilings on dashboard widgets.
• Third-party integrations need raw data. Connecting Jira to BI tools like Tableau, Power BI, or Metabase requires database-level access or API pipelines.
• Audit requirements. Compliance teams often need full change history, including deleted records — data that’s buried in the database and not surfaced in the UI.

Method 1: Direct SQL Access (Jira Server and Data Center Only)

This is the most powerful method — and the most risky if done carelessly.

Prerequisites

• Administrative access to your Jira host server
• Database credentials (usually in dbconfig.xml)
• A database client (pgAdmin, DBeaver, TablePlus, or command-line tools)

Step 1: Locate Your Database Configuration

On your Jira server, navigate to the Jira home directory. By default:

/var/atlassian/application-data/jira/dbconfig.xml

Open this file to find your:

• Database type (databaseType)
• JDBC URL (host, port, database name)
• Username and password

Step 2: Connect with a Database Client

Using DBeaver (free and widely used):

1. Open DBeaver → New Database Connection
2. Select your database type (PostgreSQL, MySQL, etc.)
3. Enter the host, port, database name, username, and password from dbconfig.xml
4. Test the connection and save

Step 3: Key Tables to Know

Once connected, here are the most important tables in the Jira schema:

Example SQL Query: Open Issues by Project

SELECT

  p.pname AS project_name,

  ji.issuenum AS issue_number,

  ji.summary,

  ji.priority,

  ji.issuestatus,

  ji.created,

  ji.updated

FROM jiraissue ji

JOIN project p ON ji.project = p.id

WHERE ji.issuestatus NOT IN (

  SELECT id FROM issuestatus WHERE pname = ‘Done’

)

ORDER BY ji.created DESC;

Critical Warning

Never run INSERT, UPDATE, or DELETE queries directly on the Jira database. Atlassian explicitly warns that direct database modifications are unsupported and can corrupt your instance. Use SQL for read-only reporting only.

Take a full database backup before connecting any external tool to your Jira database.

Method 2: Jira REST API (All Versions, Including Cloud)

If you’re on Jira Cloud — or want a safer, supported path — the REST API is your best option.

Jira’s REST API gives you programmatic access to nearly all data without touching the database directly. According to Atlassian, the REST API supports over 200 endpoints across Jira Cloud and Data Center.

Authentication Options

Jira Cloud:

• API token (recommended) — generate at id.atlassian.com
• OAuth 2.0 for third-party app integrations

Jira Server / Data Center:

• Basic authentication (username + password or API token)
• OAuth 1.0a for legacy integrations

Basic API Call Example (Python)

import requests

from requests.auth import HTTPBasicAuth

import json

# Configuration

JIRA_URL = “https://your-domain.atlassian.net”

EMAIL = “your-email@company.com”

API_TOKEN = “your_api_token”

# Authentication

auth = HTTPBasicAuth(EMAIL, API_TOKEN)

headers = {“Accept”: “application/json”}

# Search issues with JQL

params = {

    “jql”: “project = MYPROJECT AND status = ‘In Progress'”,

    “maxResults”: 100,

    “fields”: “summary,status,assignee,priority,created”

}

response = requests.get(

    f”{JIRA_URL}/rest/api/3/search”,

    headers=headers,

    auth=auth,

    params=params

)

data = response.json()

issues = data.get(“issues”, [])

for issue in issues:

    print(f”{issue[‘key’]}: {issue[‘fields’][‘summary’]}”)

Pagination for Large Datasets

Jira limits API responses to 100 issues per request by default. For larger datasets, paginate using startAt:

all_issues = []

start_at = 0

max_results = 100

while True:

    params[“startAt”] = start_at

    params[“maxResults”] = max_results

    response = requests.get(f”{JIRA_URL}/rest/api/3/search”, headers=headers, auth=auth, params=params)

    data = response.json()

    issues = data.get(“issues”, [])

    all_issues.extend(issues)

    if len(issues) < max_results:

        break

    start_at += max_results

print(f”Total issues retrieved: {len(all_issues)}”)

Rate Limits to Know

Jira Cloud enforces rate limits. As of Atlassian’s current guidelines:

• REST API: ~10 requests per second per user token
• Exceeding limits returns a 429 Too Many Requests response
• Add retry logic with exponential backoff for production scripts

Method 3: Jira’s Built-In Data Export Tools

Sometimes you don’t need a database connection or API at all.

For lighter use cases, Jira’s export features handle the job.

CSV Export via Issue Navigator

1. Navigate to Issues → Search for Issues
2. Build your JQL filter
3. Click Export → Export Excel CSV (All Fields) or Export Excel CSV (Current Fields)
4. Open in Excel, Google Sheets, or import into your BI tool

This works well for one-off reports or when you need data from fewer than ~2,000 issues.

Jira Gadgets and Dashboard Widgets

For recurring reports without technical setup:

• Two-Dimensional Filter Statistics — cross-tab issue counts by any two fields
• Filter Results — live list of issues matching a saved filter
• Average Age Chart — trend data on unresolved issues
• Pie Chart Gadget — quick breakdowns by assignee, priority, or status

Jira Automation + Webhook Exports

For teams on Jira Cloud with automation enabled, you can trigger data pushes to external systems (Google Sheets, Slack, webhooks) using Jira’s built-in automation rules. No code required.

Method 4: Third-Party Database Connectors and BI Integrations

For teams that need real-time Jira data in reporting tools, several connectors eliminate the need to build your own pipeline.

Popular Options

Fivetran / Airbyte — Extract Jira data into a data warehouse (BigQuery, Snowflake, Redshift) on a schedule. Fivetran’s Jira connector syncs over 40 Jira tables automatically.

Tableau / Power BI Web Connectors — Native Jira connectors exist in both tools. You authenticate with your Jira credentials and pull data directly into your dashboard.

Atlassian Analytics (Jira Cloud Premium/Enterprise) — Built-in analytics suite with a no-code data model. Available on Jira Cloud Premium and Enterprise plans.

Confluence + Jira Data Integration — For teams already on Confluence, macros like the Jira Issues macro pull live issue data directly into documentation pages.

Method 5: ScriptRunner and Groovy Scripts (Advanced)

For Jira Server and Data Center teams using the ScriptRunner plugin, you can query the Jira database programmatically through Atlassian’s internal Java APIs — no direct SQL or external tools needed.

import com.atlassian.jira.component.ComponentAccessor

import com.atlassian.jira.issue.search.SearchProvider

def issueManager = ComponentAccessor.getIssueManager()

def project = ComponentAccessor.getProjectManager().getProjectByCurrentKey(“MYPROJECT”)

def issues = issueManager.getIssueObjects(issueManager.getIssueIdsForProject(project.id))

issues.each { issue ->

    log.warn(“${issue.key}: ${issue.summary} – ${issue.status.name}”)

}

ScriptRunner gives you access to the full Jira object model — issues, users, workflows, custom fields — without the risks of raw SQL.

Database Performance Considerations

Direct database access under load can impact Jira’s performance. Research on large Jira deployments shows:

• Instances with 100,000+ issues commonly see query times spike under concurrent read operations
• Atlassian recommends running heavy read queries against a database replica, not your primary Jira database
• Jira Data Center supports read-only database replicas specifically for analytics and reporting workloads
• Poorly indexed custom field queries are the #1 cause of slow Jira database performance, according to Atlassian’s performance troubleshooting guides

If you’re running frequent large queries, work with your DBA to add appropriate indexes on jiraissue.project, jiraissue.issuestatus, and customfieldvalue.issue.

Security Best Practices

Accessing the Jira database — especially directly — carries real security risk. Follow these non-negotiables:

• Use read-only database users for any reporting connection. Never give external tools write access.
• Rotate API tokens regularly. Treat Jira API tokens like passwords — don’t embed them in code repositories.
• Audit who has database access. Jira’s user data is sensitive. Keep the list of people with direct DB access short.
• Use environment variables for credentials in any scripts. Never hardcode tokens or passwords.
• Log all direct database queries for compliance traceability.

According to a 2023 Verizon Data Breach Investigations Report, 74% of breaches involve a human element — including stolen credentials and misuse of access privileges. Database access controls are not optional.

Choosing the Right Method

Conclusion

Accessing the Jira database isn’t one-size-fits-all. The right method depends on your deployment type, technical comfort level, and what you need the data for.

• Direct SQL gives you the most power on Server and Data Center — use it carefully, read-only, on a replica where possible.
• REST API is the right long-term approach on Cloud and for any production pipeline that needs to be reliable and supported.
• CSV exports and dashboard gadgets handle most ad hoc reporting needs without any technical setup.
• BI connectors like Fivetran and Tableau are the clean solution when stakeholders need live dashboards.

Whatever method you use, get the security basics right first: read-only access, rotated credentials, and auditable query logs.

Once your data infrastructure is solid, the next challenge is turning insights into revenue. If you’re looking to build an outbound engine that converts data into qualified meetings — book a strategy session with SalesSo to see exactly how we do it.