Is Concur Down? How to Check SAP Concur Status in Real-Time

Quick Answer: To check if Concur is down, visit apistatuscheck.com/api/concur for real-time monitoring, or check the official concur.com/status page. Common signs include expense report submission failures, receipt upload errors, approval workflow delays, mobile app sync issues, and SSO authentication problems.

When your expense management system suddenly stops working, it creates chaos for employees trying to submit expenses and finance teams managing reimbursements. SAP Concur is the backbone of corporate expense management for thousands of organizations worldwide, making any downtime a critical business blocker. Whether you're seeing failed expense submissions, receipt upload errors, or mobile app sync issues, knowing how to quickly verify Concur's status can save you valuable troubleshooting time and prevent month-end closing delays.

How to Check Concur Status in Real-Time

1. API Status Check (Fastest Method)

The quickest way to verify Concur's operational status is through apistatuscheck.com/api/concur. This real-time monitoring service:

• Tests actual API endpoints every 60 seconds
• Shows response times and latency trends
• Tracks historical uptime over 30/60/90 days
• Provides instant alerts when issues are detected
• Monitors authentication systems (SSO, OAuth)
• Tests mobile API endpoints used by the Concur mobile app

Unlike status pages that rely on manual updates, API Status Check performs active health checks against Concur's production endpoints, giving you the most accurate real-time picture of service availability across web, mobile, and API interfaces.

2. Official SAP Concur Status Page

SAP Concur maintains concur.com/status as their official communication channel for service incidents. The page displays:

• Current operational status for all data centers
• Active incidents and investigations
• Scheduled maintenance windows
• Historical incident reports
• Component-specific status (Expense, Travel, Invoice, Mobile)
• Data center status by region (US, EU, APAC)

Pro tip: Subscribe to status updates via email on the status page to receive immediate notifications when incidents occur in your specific data center region.

3. Check the Concur Mobile App

The Concur mobile app often shows issues before the web interface:

• App crashes or fails to load
• "Unable to sync" error messages
• Receipt photos failing to upload
• Expense submissions stuck in "Saving..." state
• Login failures despite correct credentials

If the mobile app is experiencing issues while the website works, this may indicate problems with Concur's mobile API infrastructure specifically.

4. Test Web Login and Core Functions

Visit concursolutions.com and test:

• SSO authentication (does it redirect properly?)
• Expense report creation (can you create a new report?)
• Receipt attachment (do uploads complete?)
• Report submission (does the submit button work?)
• Approval workflows (can approvers see pending items?)

5. Check Your Integration Endpoints

For companies with Concur API integrations, test connectivity directly:

# Test OAuth authentication
curl -X POST https://us.api.concursolutions.com/oauth2/v0/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET" \
  -d "grant_type=client_credentials"

Look for authentication failures, timeout errors, or 500-series HTTP response codes.

Common Concur Issues and How to Identify Them

Expense Report Submission Failures

Symptoms:

• "Unable to submit expense report" error messages
• Submit button unresponsive or spinning indefinitely
• Reports disappearing after submission attempt
• Validation errors that don't make sense
• 500 Internal Server Error messages

What it means: When expense submission is degraded, legitimate reports that meet all policy requirements start failing. This differs from normal policy violations—you'll see a pattern of failures across different employees and expense types.

Receipt Upload Errors

Common issues during outages:

• "Upload failed" messages on mobile or web
• Receipt images not attaching to expense lines
• Upload progress stuck at 0% or incomplete
• Previously uploaded receipts showing as missing
• OCR (optical character recognition) failures

Mobile-specific symptoms:

• Camera integration fails to capture receipts
• "Receipt not saved" after successful photo capture
• Sync failures preventing upload queue from processing

Receipt uploads depend on both Concur's storage infrastructure and image processing services, so failures here often indicate backend storage or processing outages.

Approval Workflow Delays

Signs approval systems are impacted:

• Approvers not receiving email notifications
• Submitted reports stuck in "Pending Approval" for hours/days
• Approval actions (Approve/Reject) not processing
• Delegates unable to act on behalf of managers
• Reports disappearing from approval queues

Approval workflow issues directly impact employee reimbursement timelines and month-end close processes.

Mobile App Sync Issues

Indicators of mobile API problems:

• "Last synced X days ago" despite good internet connection
• Offline mode activating unexpectedly
• Data discrepancies between mobile and web
• Draft expenses not appearing across devices
• Location services (mileage tracking) failing

Since many employees rely on mobile expense submission, mobile API outages disproportionately impact user experience and adoption.

SSO Authentication Problems

Single Sign-On failure patterns:

• Redirect loop between identity provider and Concur
• "Authentication failed" with valid credentials
• SAML assertion errors
• Unable to access Concur after successful IdP login
• Intermittent authentication failures (works sometimes, fails others)

SSO issues can lock out entire organizations from Concur access, making this the highest-priority incident type for IT teams.

Integration and API Failures

For companies with automated integrations:

API error codes during outages:

• 500 Internal Server Error - Concur server-side issue
• 502 Bad Gateway - Load balancer cannot reach backend
• 503 Service Unavailable - Temporary overload or maintenance
• 504 Gateway Timeout - Request processing too slow
• 401 Unauthorized - OAuth token service down

Webhook delivery problems:

• Expense submission webhooks not firing
• Invoice approval notifications delayed
• Travel booking events missing
• Retry attempts exhausted

Data Center Regional Outages

Concur operates multiple data centers globally. Issues may affect:

• US Data Center: North American customers only
• EU Data Center: European customers only
• APAC Data Center: Asia-Pacific customers only

Check the status page for data center-specific incidents. Your organization is typically assigned to one primary data center based on your contract region.

The Real Impact When Concur Goes Down

Employee Reimbursement Delays

Every hour of Concur downtime creates a backlog of expenses:

• Employees cannot submit expense reports for reimbursement
• Approved reports cannot process for payment
• Urgent advances blocked for upcoming travel
• Out-of-pocket expenses pile up creating employee frustration

For organizations processing thousands of expense reports monthly, even a 4-hour outage can delay reimbursements by days or weeks as teams work through the backlog.

Travel Booking Disruption

Concur Travel integration enables employees to book flights, hotels, and rental cars within policy:

• New bookings fail leaving employees unable to arrange business travel
• Itinerary changes blocked forcing manual rebooking
• Travel approvals stalled delaying time-sensitive trips
• Traveler profile access issues preventing bookings

For organizations with frequent business travel, this disruption can ground employees and impact customer meetings, conferences, and on-site work.

Month-End Financial Closing Delays

Finance teams depend on Concur for accurate expense reporting:

• Expense reports stuck in workflow cannot be closed
• Accrual reports incomplete due to missing submissions
• Credit card reconciliation halted when transaction feeds fail
• AP (Accounts Payable) processing delayed for vendor invoices
• General ledger posting blocked affecting financial statements

For public companies or organizations with tight close schedules, Concur outages during month-end can jeopardize regulatory filing deadlines and financial reporting accuracy.

Compliance and Audit Risk

Expense policy enforcement depends on Concur availability:

• Policy violations go undetected when validation rules fail
• Audit trails incomplete if system logging is affected
• Receipt retention requirements at risk if uploads fail
• IRS mileage documentation missing from failed submissions

Post-outage, compliance teams may need to manually review expense reports that bypassed normal policy checks.

Employee Satisfaction and Adoption

Poor system reliability impacts user experience:

• Frustration with resubmitting expenses after failures
• Lost confidence in the platform reducing adoption
• Shadow expense tracking in spreadsheets (compliance risk)
• Increased support tickets overwhelming IT helpdesk
• Negative perception of digital transformation initiatives

For organizations recently migrated to Concur, outages during the critical adoption phase can undermine change management efforts and drive users back to manual processes.

Integration Partner Disruption

Modern enterprises connect Concur to other systems:

• ERP integration failures (SAP, Oracle, NetSuite)
• HRIS sync issues (Workday, ADP, BambooHR)
• Corporate card feeds broken (Amex, Visa, Mastercard)
• Accounting system delays (QuickBooks, Xero)

When Concur APIs fail, downstream systems experience data gaps requiring manual reconciliation.

Incident Response Playbook: What to Do When Concur Goes Down

1. Verify the Outage Scope

Before declaring an incident, confirm the issue:

// Automated health check for Concur availability
const checkConcurHealth = async () => {
  const endpoints = [
    'https://us.api.concursolutions.com/oauth2/v0/token',
    'https://www.concursolutions.com/api/v3.0/common/connectionrequests',
    'https://mobile.concursolutions.com/api/health'
  ];
  
  const results = await Promise.allSettled(
    endpoints.map(url => 
      fetch(url, { method: 'HEAD', timeout: 5000 })
    )
  );
  
  const failureCount = results.filter(r => r.status === 'rejected').length;
  
  if (failureCount > 1) {
    await notifyOncall({
      severity: 'critical',
      message: `Concur health check failed: ${failureCount}/${endpoints.length} endpoints down`,
      runbook: 'https://wiki.company.com/concur-outage-runbook'
    });
  }
};

Determine impact:

• Is it affecting all users or specific departments?
• Which functions are impacted (web, mobile, API)?
• What's the business priority (month-end close, urgent travel)?

2. Enable Emergency Workarounds

For employee expenses:

// Activate offline expense collection form
app.post('/emergency-expense-submit', async (req, res) => {
  const { employeeId, amount, category, receipt, description } = req.body;
  
  // Store in emergency queue for later Concur sync
  await db.emergencyExpenses.create({
    employeeId,
    amount,
    category,
    receiptBase64: receipt,
    description,
    submittedAt: new Date(),
    concurSyncStatus: 'pending',
    emergencySubmission: true
  });
  
  // Notify employee
  await email.send({
    to: req.user.email,
    subject: 'Expense Recorded - Will Sync to Concur When Available',
    body: `Your expense for ${formatCurrency(amount)} has been recorded and will be automatically submitted to Concur when the system is available. Reference: ${submissionId}`
  });
  
  res.json({ success: true, message: 'Expense queued for submission' });
});

For urgent travel bookings:

• Provide direct booking phone numbers for travel partners
• Authorize temporary out-of-policy bookings with manager approval
• Enable manual travel request form submission via email

For approvals:

• Implement temporary email-based approval process
• Document approvals for later entry into Concur
• Extend approval deadlines to account for downtime

3. Communicate Proactively with Stakeholders

Immediate notification (within 15 minutes of confirmed outage):

// Multi-channel incident notification
const notifyStakeholders = async (incident) => {
  const message = `
🚨 Concur Outage Detected

Status: ${incident.status}
Impact: ${incident.impactedFunctions.join(', ')}
Estimated Resolution: ${incident.eta || 'Under investigation'}

Workarounds:
• Use emergency expense form: https://intranet.company.com/expense-emergency
• Contact travel desk for urgent bookings: 1-800-XXX-XXXX
• Questions: #concur-support in Slack

Live updates: https://status.company.com/concur
  `;
  
  // Send to multiple channels
  await Promise.all([
    slack.postMessage('#general', message),
    email.sendToGroup('all-employees@company.com', 'Concur Service Disruption', message),
    sms.sendToOncall(message),
    intranet.postBanner(message)
  ]);
};

Target audiences:

• All employees (via email/Slack)
• Finance team (direct communication)
• Travel coordinators
• Executive assistants
• IT helpdesk (prepare for support tickets)

Update frequency:

• Initial notification: Immediately upon confirmation
• Progress updates: Every 30-60 minutes
• Resolution notification: When service restored
• Post-mortem: Within 24-48 hours of resolution

4. Implement Concur API Retry Logic

For automated integrations, implement intelligent retry:

// Robust retry mechanism with exponential backoff
class ConcurClient {
  async makeRequest(endpoint, options = {}, attempt = 1) {
    const maxRetries = 5;
    const baseDelay = 1000; // 1 second
    
    try {
      const response = await fetch(endpoint, {
        ...options,
        headers: {
          'Authorization': `Bearer ${await this.getValidToken()}`,
          'Content-Type': 'application/json',
          ...options.headers
        },
        timeout: 30000 // 30 second timeout
      });
      
      // Check for Concur-specific error patterns
      if (response.status >= 500) {
        throw new ConcurServerError(response.status, await response.text());
      }
      
      // Rate limiting - back off
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After') || 60;
        throw new ConcurRateLimitError(retryAfter);
      }
      
      return await response.json();
      
    } catch (error) {
      // Don't retry auth failures or client errors
      if (error.status >= 400 && error.status < 500) {
        throw error;
      }
      
      // Retry server errors and timeouts
      if (attempt < maxRetries) {
        const delay = baseDelay * Math.pow(2, attempt - 1); // Exponential backoff
        console.log(`Concur request failed, retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`);
        
        await new Promise(resolve => setTimeout(resolve, delay));
        return this.makeRequest(endpoint, options, attempt + 1);
      }
      
      // All retries exhausted
      throw new ConcurOutageError(`Failed after ${maxRetries} attempts: ${error.message}`);
    }
  }
  
  // Token management with refresh logic
  async getValidToken() {
    if (this.tokenExpiry && Date.now() < this.tokenExpiry) {
      return this.accessToken;
    }
    
    // Refresh token
    const response = await fetch('https://us.api.concursolutions.com/oauth2/v0/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        client_id: process.env.CONCUR_CLIENT_ID,
        client_secret: process.env.CONCUR_CLIENT_SECRET,
        grant_type: 'client_credentials'
      })
    });
    
    const data = await response.json();
    this.accessToken = data.access_token;
    this.tokenExpiry = Date.now() + (data.expires_in * 1000);
    
    return this.accessToken;
  }
}

5. Handle Webhook Delivery Delays

When Concur webhooks fail during outages:

// Polling fallback for critical events
const pollExpenseReports = async () => {
  const lastCheck = await db.config.get('lastExpenseCheck');
  const now = new Date();
  
  // Query Concur API for reports modified since last check
  const reports = await concur.makeRequest(
    `/expensereports?modifiedDateAfter=${lastCheck.toISOString()}`,
    { method: 'GET' }
  );
  
  // Process new/updated reports
  for (const report of reports.items) {
    // Check if we already processed this via webhook
    const existing = await db.expenses.findOne({ concurReportId: report.id });
    
    if (!existing || existing.modifiedDate < report.modified) {
      await processExpenseReport(report);
      console.log(`Processed report ${report.id} via polling fallback`);
    }
  }
  
  await db.config.set('lastExpenseCheck', now);
};

// Run polling every 15 minutes during suspected outages
if (concurWebhooksDelayed) {
  setInterval(pollExpenseReports, 15 * 60 * 1000);
}

6. Post-Outage Recovery Checklist

Once Concur service is restored:

Immediate actions (first hour):

1. ✅ Verify all core functions operational (web, mobile, API, SSO)
2. ✅ Test critical integrations (ERP, HRIS, corporate card feeds)
3. ✅ Process queued emergency expense submissions
4. ✅ Verify webhook delivery resumed
5. ✅ Notify users that service is restored

Within 24 hours:

1. ✅ Review expense report backlog and expedite urgent submissions
2. ✅ Reconcile emergency expenses with Concur submissions
3. ✅ Check for duplicate submissions (users may have tried multiple times)
4. ✅ Audit policy violations that may have bypassed normal checks
5. ✅ Review integration data for gaps or inconsistencies

Within 1 week:

1. ✅ Analyze impact metrics (lost productivity, delayed reimbursements)
2. ✅ Conduct post-mortem with SAP Concur (if enterprise customer)
3. ✅ Update incident response runbook with lessons learned
4. ✅ Review and improve monitoring/alerting
5. ✅ Consider architectural changes to improve resilience

Monitoring Concur Health Proactively

Automated Monitoring Setup

// Comprehensive Concur monitoring
class ConcurMonitor {
  constructor() {
    this.checks = [
      { name: 'OAuth Authentication', endpoint: '/oauth2/v0/token', method: 'POST' },
      { name: 'Expense API', endpoint: '/api/v3.0/expense/reports', method: 'GET' },
      { name: 'User API', endpoint: '/api/v3.0/common/users', method: 'GET' },
      { name: 'Mobile API', endpoint: '/mobile/api/health', method: 'HEAD' }
    ];
  }
  
  async runHealthChecks() {
    const results = await Promise.all(
      this.checks.map(async (check) => {
        const startTime = Date.now();
        try {
          await concur.makeRequest(check.endpoint, { method: check.method });
          return {
            name: check.name,
            status: 'healthy',
            responseTime: Date.now() - startTime
          };
        } catch (error) {
          return {
            name: check.name,
            status: 'unhealthy',
            error: error.message,
            responseTime: Date.now() - startTime
          };
        }
      })
    );
    
    // Alert if multiple checks fail
    const unhealthyCount = results.filter(r => r.status === 'unhealthy').length;
    if (unhealthyCount >= 2) {
      await this.triggerAlert(results);
    }
    
    // Log metrics for trending
    await metrics.record('concur_health_check', results);
    
    return results;
  }
  
  async triggerAlert(results) {
    const unhealthy = results.filter(r => r.status === 'unhealthy');
    await notifications.send({
      severity: 'critical',
      title: 'Concur Outage Detected',
      message: `${unhealthy.length} health checks failing: ${unhealthy.map(r => r.name).join(', ')}`,
      details: results,
      actions: [
        { label: 'View Status', url: 'https://apistatuscheck.com/api/concur' },
        { label: 'Incident Runbook', url: 'https://wiki.company.com/concur-outage' }
      ]
    });
  }
}

// Run every 60 seconds
setInterval(() => new ConcurMonitor().runHealthChecks(), 60000);

Related Enterprise Service Monitoring

Concur often integrates with other enterprise systems. Monitor these dependencies:

• Is SAP Down? - ERP integration for expense posting
• Is Workday Down? - HRIS sync for employee data
• Is Salesforce Down? - CRM integration for opportunity expenses
• Is ServiceNow Down? - IT service desk for support tickets
• Is Okta Down? - SSO authentication provider

When Concur is working but integrations fail, the issue may be with the connected system rather than Concur itself.

Frequently Asked Questions

How often does Concur go down?

SAP Concur maintains strong uptime, typically exceeding 99.5% availability. Major outages affecting all customers are relatively rare (3-6 times per year), though regional data center issues or component-specific problems (mobile, API, specific modules) may occur more frequently. Most enterprise customers experience 1-2 noticeable incidents per year affecting their operations.

What's the difference between Concur status page and API Status Check?

The official SAP Concur status page is manually updated by their operations team during incidents, which can sometimes lag behind actual issues by 10-30 minutes. API Status Check performs automated health checks every 60 seconds against live endpoints (authentication, APIs, mobile), often detecting issues before they're officially reported. Use both for comprehensive visibility.

Can I get SLA credits for Concur downtime?

Enterprise customers with custom agreements may have SLA terms including downtime credits. Standard agreements typically include uptime targets but exclude liability for consequential damages. Review your specific SAP Concur contract or contact your account executive to understand your SLA terms and credit eligibility.

How do I prevent duplicate expense submissions during outages?

Educate employees not to repeatedly submit the same expense if they receive errors. Implement deduplication logic in your integrations by checking expense IDs before processing. After outages, audit for duplicate submissions by searching for expenses with matching amounts, dates, vendors, and employees within a short time window.

Should I use Concur webhooks or API polling for critical integrations?

For critical integrations (ERP posting, payment processing), implement a hybrid approach: rely on webhooks for real-time updates during normal operation, but include scheduled API polling (every 15-30 minutes) as a backup. During outages, webhooks may be delayed or lost, so polling ensures you don't miss important expense approvals or report submissions.

What data center region is my Concur instance in?

Your data center assignment is determined during implementation based on your primary business location. Check your Concur login URL: https://www.concursolutions.com (US), https://eu1.concursolutions.com (Europe), or https://ap1.concursolutions.com (Asia-Pacific). Contact SAP Concur support if you need to verify or request a data center change.

How long does Concur typically take to resolve outages?

Resolution time varies by incident severity and root cause. Minor issues (single component) often resolve within 1-2 hours. Major outages affecting core functionality typically resolve within 4-8 hours. Database or infrastructure issues can extend to 12-24 hours. SAP Concur status page provides ETAs during active incidents, though these are estimates subject to change.

Can I export Concur data for offline access during outages?

Yes, Concur provides data extraction APIs and scheduled extract files. Set up regular exports of critical data (expense reports, approvals, employee data) to your local systems. This enables read-only access during outages and supports business continuity. Work with your Concur administrator to configure extract files via the Concur Extract API or scheduled file delivery.

What should I do if SSO is down but Concur itself is up?

SSO failures can originate from your identity provider (Okta, Azure AD, Ping) or Concur's SAML assertion service. First, verify your IdP status using our identity provider monitoring guides. If your IdP is operational, the issue is with Concur's authentication service. As a workaround, SAP Concur support can temporarily enable direct username/password login for critical users while SSO is restored.

How do I report a Concur issue to SAP support?

For enterprise customers:

• Call your dedicated support line (provided during implementation)
• Submit a case via Concur Client Central support portal
• For P1/critical outages, ask for the on-call escalation team

Critical information to provide:

• Exact error messages or screenshots
• Affected user count and departments
• Business impact (month-end close, urgent travel, etc.)
• Steps to reproduce
• Your data center region

Stay Ahead of Concur Outages

Don't let expense management disruptions catch you off guard. Subscribe to real-time Concur alerts and get notified instantly when issues are detected—before your employees start flooding the helpdesk.

API Status Check monitors Concur 24/7 with:

• 60-second health checks across authentication, APIs, and mobile
• Instant alerts via email, Slack, Discord, or webhook
• Historical uptime tracking and incident reports
• Multi-system monitoring for your entire enterprise stack (SAP, Workday, Salesforce)

Start monitoring Concur now →

---

Last updated: February 4, 2026. Concur status information is provided in real-time based on active monitoring. For official incident reports, always refer to concur.com/status or contact SAP Concur support.