> Continuous Process Improvement > Expense Management > Coupa Expenses > Data Template

Your Expense Management Data Template

Coupa Expenses

Expense Management Attributes (21) Expense Management Activities (13) Extraction Guides (2)

Your Expense Management Data Template

This comprehensive data template provides a structured approach to analyzing your expense management process within Coupa Expenses. It outlines the essential data attributes to collect, the critical activities to track, and practical guidance on data extraction. Use this template to ensure you gather all necessary information for a thorough process mining analysis.

Recommended attributes for comprehensive data collection
Key expense management activities to track
Step-by-step guidance for data extraction from Coupa Expenses

New to event logs? Learn how to create a process mining event log.

Download Template

Expense Management Attributes

These are the recommended data fields to include in your event log for a comprehensive analysis of your expense management process.

5 Required 7 Recommended 9 Optional

	Name	Description
	Activity Name ActivityName	The name of the business event that occurred at a specific point in time for an expense report.
Description The Activity Name describes a specific step or milestone in the expense management process, such as 'Expense Report Submitted', 'Manager Approved', or 'Reimbursement Executed'. These activities form the nodes in the process map and are the basis for analyzing process flow, bottlenecks, and variations. Analysis of this attribute helps to understand the sequence of events, frequency of different process steps, and transitions between them. It is fundamental for building the process map, calculating transition times, and identifying common or non-compliant process paths. Why it matters This attribute defines the steps in the process, allowing for the visualization and analysis of the process flow, which is the core of process mining. Where to get This is typically derived from event logs, status change records, or audit trail tables associated with the expense report object in Coupa. It may require mapping from status codes or event types to user-friendly names. Examples Expense Report SubmittedManager ApprovedFinance RejectedReimbursement Executed
	Event Time EventTime	The timestamp indicating when an activity or event occurred.
Description Event Time is the precise date and time that a specific activity was recorded in the system. This timestamp is essential for ordering events chronologically and for all time-based analysis. It provides the factual basis for understanding the timing and duration of process steps. In process mining, this attribute is used to construct the timeline of each case, calculate the duration between activities, identify delays, and measure overall cycle times. It is critical for analyzing performance, adherence to service level agreements, and identifying temporal patterns or bottlenecks. Why it matters This timestamp provides the chronological order of events and is the foundation for all duration and performance-based analysis, including cycle time and bottleneck identification. Where to get This information is found in the audit trail or event log tables in Coupa, typically alongside the record of the activity or status change. Examples 2023-10-26T10:00:00Z2023-10-26T14:35:10Z2023-10-27T09:15:00Z
	Expense Report ID ExpenseReportId	The unique identifier for an expense report, which groups all related activities and expenses for a single submission.
Description The Expense Report ID serves as the primary case identifier, grouping all events and activities related to a single submission of expenses. Each expense report is assigned a unique ID upon creation, allowing for a complete, chronological tracking of an expense claim from its initial entry to its final payment. In process mining analysis, this ID is crucial for reconstructing the end-to-end journey of each expense report. It allows analysts to visualize process flows, identify variations in processing paths, and calculate case-level metrics such as total cycle time and rework loops for individual claims. Why it matters This is the essential key to connect all related events for a single expense claim, making it possible to analyze the entire process from start to finish. Where to get This is a primary key in Coupa's expense report objects, often found as 'id' or 'report-id' in the Expense Reports API endpoint or underlying tables. Examples ER-0012345ER-0012399ER-0013001
	Last Data Update LastDataUpdate	The timestamp of the last data refresh or extraction from the source system.
Description This attribute records the date and time when the data was last extracted from Coupa Expenses and loaded into the process mining tool. It indicates the freshness of the data being analyzed. This information is vital for users to understand the timeliness of the analysis and to know if the dashboards reflect the most current state of operations. It is a key piece of metadata for data governance and ensuring trust in the analytical results. Why it matters Informs users about the freshness of the data, ensuring they understand the time frame of the analysis and can trust its relevance. Where to get This timestamp is typically generated and stored by the data extraction or ETL tool at the end of a successful data load. Examples 2024-05-21T02:00:00Z2024-05-22T02:00:00Z
	Source System SourceSystem	The system from which the data originates.
Description This attribute identifies the source application where the event data was generated. In this context, it would be 'Coupa Expenses'. It is important for data governance and for distinguishing data from different systems in a multi-system process view. It provides context about the data's origin, which can be relevant when analyzing processes that span multiple applications. Why it matters Provides essential context about the data's origin, which is crucial for data governance, validation, and multi-system process analysis. Where to get This is typically a static value added during data extraction and transformation to label the dataset's origin. Examples Coupa ExpensesCoupa
	Employee Department EmployeeDepartment	The department of the employee who submitted the expense report.
Description This attribute specifies the organizational department or business unit to which the expense report submitter belongs. This information is typically derived from employee master data. It is a critical dimension for analysis, allowing for the comparison of process performance across different parts of the organization. Dashboards that analyze approval times, rejection rates, or policy violations by department rely heavily on this attribute to identify areas needing process improvement or targeted training. Why it matters Allows for performance comparison across different departments, helping to identify which parts of the organization are efficient and which may need support. Where to get Sourced from the submitting user's profile in Coupa or by joining with an external HR master data system using the user ID. Look for a 'department' field on the user object. Examples SalesMarketingEngineeringFinance
	End Time EndTime	The timestamp indicating when an activity was completed.
Description The End Time marks the conclusion of an activity. In many transactional systems, an activity is an instantaneous event, so the End Time is the same as the Start Time. However, for activities that have a measurable duration, this attribute captures when it finished. This field is crucial for calculating the precise processing time of individual activities. It enables more accurate analysis of where time is spent within the process, helping to distinguish waiting time from actual work time. Why it matters Enables the calculation of precise activity durations, which is critical for identifying and analyzing the time spent on specific tasks versus waiting time. Where to get This is often the same as the Start Time (EventTime) for atomic events. For durational activities, it may need to be sourced from a separate field or derived based on the next event's timestamp. Examples 2023-10-26T10:00:00Z2023-10-26T14:35:10Z2023-10-27T09:15:00Z
	Expense Report Status ExpenseReportStatus	The current or final status of the expense report.
Description This attribute indicates the overall state of the expense report at the end of its lifecycle, such as 'Approved', 'Paid', 'Rejected', or 'Withdrawn'. This provides a conclusive outcome for each case. In analysis, the final status is used to filter for completed cases and to categorize outcomes. It's essential for calculating metrics like rejection rates and understanding the proportion of reports that reach each possible end state. It also helps in identifying reports that are stuck in an intermediate status. Why it matters Defines the outcome of each case, which is fundamental for outcome-based analysis, such as comparing the paths of approved versus rejected reports. Where to get This is a primary status field on the expense report object in Coupa. It can be found in the header data and is updated throughout the process. Examples pending_approvalapprovedpaidrejected
	Policy Violation Flag PolicyViolationFlag	A boolean indicator that is true if the expense report was flagged for a policy violation.
Description Coupa can automatically flag expenses that violate company policy, such as exceeding spending limits or using unapproved vendors. This attribute is a simple true or false flag indicating whether such a violation was detected for the expense report. This flag is essential for compliance monitoring and analysis. It allows for the creation of dashboards that track the rate of policy violations over time and across departments. It also enables analysis of how policy-violating reports are handled differently from compliant ones, for example, if they take longer to approve or are rejected more often. Why it matters Enables direct measurement and analysis of policy compliance, helping to identify and address areas of high risk or frequent non-adherence. Where to get This is typically available as a flag or status on the expense report or individual expense lines in Coupa. It is often set by the system's rules engine. Examples truefalse
	Rejection Reason RejectionReason	The reason provided when an expense report is rejected by an approver.
Description When an approver, either a manager or finance team member, rejects an expense report, they often provide a reason. This attribute captures that reason, which could be from a predefined list or free-form text. This is a highly valuable attribute for root cause analysis. By analyzing the most common rejection reasons, organizations can identify areas where policies are unclear, employees need more training, or the submission process is flawed. This directly supports efforts to reduce rework and improve the first-pass approval rate. Why it matters Directly explains why rework occurs, providing actionable insights for reducing rejection rates through targeted training, policy clarification, or process improvements. Where to get This information is typically captured in the audit trail or comments associated with a rejection event in Coupa. It may be in a dedicated field or parsed from comments. Examples Receipt missingOut-of-policy expenseIncorrect expense categoryDuplicate submission
	Total Amount TotalAmount	The total monetary value of the expense report.
Description This attribute represents the total sum of all expense lines included in the report. It is a key financial metric for understanding the value flowing through the process. Analyzing the total amount helps in segmenting expense reports into different value bands, which may have different approval paths or levels of scrutiny. It is used in dashboards to analyze spending patterns, identify high-value reports that may be causing bottlenecks, and correlate report value with processing times or rejection rates. Why it matters Provides financial context to the process, enabling analysis based on the monetary value of expense reports, which often influences approval paths and processing priority. Where to get This is a standard field on the expense report header in Coupa, often named 'total' or 'total-amount'. Examples 150.752500.0085.50
	User Name UserName	The name of the employee or user who performed the activity.
Description This attribute identifies the individual associated with a specific event, such as the person who submitted, approved, or rejected an expense report. It can be a name, an employee ID, or a system user account. Analyzing the process by user helps identify performance patterns, workload distribution, and potential training needs. It is key for dashboards that break down metrics by resource, such as comparing approval times between different managers. Why it matters Attributes work to specific individuals, enabling analysis of workload, performance, and resource-specific behavior within the process. Where to get This information is usually available in the audit trail tables of Coupa Expenses, linked to each event or action. Look for fields like 'user-id', 'submitted-by', or 'updated-by'. Examples John Smithjsmith11023
	Activity Processing Time ActivityProcessingTime	The duration of an individual activity, calculated as the difference between its end and start time.
Description This metric measures the time spent performing a single process step. It is calculated by subtracting the activity's start time from its end time. For instantaneous events, this duration is zero. This calculated attribute helps differentiate between active processing time and waiting time (the time between activities). Analyzing processing times helps identify which specific tasks are the most time-consuming, pointing to opportunities for automation or task optimization. Why it matters Measures the time spent on value-adding work, helping to distinguish it from idle or wait time and identify inefficient tasks. Where to get This is calculated during data transformation by subtracting the 'EventTime' (StartTime) from the 'EndTime'. Formula: EndTime - StartTime. Examples 0864003600
	Approver Name ApproverName	The name of the manager or finance user who approved or rejected the expense report.
Description This attribute identifies the specific approver involved in a manager or finance approval step. This is distinct from the user who submitted the report. This data is useful for analyzing the performance and behavior of approvers. It allows for the measurement of approval cycle times per individual approver, helping to identify bottlenecks caused by specific individuals who may be overloaded or require additional training. It supports dashboards that aim to balance workload and improve approval efficiency. Why it matters Helps pinpoint bottlenecks in the approval chain by attributing delays or high rejection rates to specific approvers, enabling targeted interventions. Where to get Found in the approval history or audit trail of the expense report in Coupa. Each approval step should have a record of the user who took the action. Examples Sarah ChenDavid RodriguezFinance Team Queue
	Cost Center CostCenter	The cost center to which the expenses are allocated.
Description The Cost Center is a financial dimension used for accounting and budgeting, indicating which part of the organization will bear the cost of the expenses. It may differ from the submitter's own department. Analyzing by Cost Center provides a financial accounting view on the process. It allows for tracking spending and process efficiency against specific budgets or financial units. This is particularly important for finance departments looking to understand and manage organizational spend. Why it matters Provides a crucial financial dimension for analysis, allowing process metrics to be linked directly to financial and budgetary units. Where to get This is a standard accounting field in Coupa, found on the expense report header or line items. It is often part of the Chart of Accounts structure. Examples CC4510-MarketingCC2100-EngineeringCC7800-Sales-East
	Country Country	The country of the submitting employee or the transaction.
Description This attribute indicates the country associated with the expense report, which is usually the home country of the submitting employee. This is a key dimension for analyzing processes in a global organization. Analyzing the process by country helps to compare performance, compliance, and process variations across different geographical regions. This can highlight regional differences in regulations, policies, or operational efficiency that need to be addressed. Why it matters Enables comparison of process performance and compliance across different geographical regions, which is essential for global organizations. Where to get This can be derived from the user's profile in Coupa or from the legal entity associated with the expense report. Examples USADEUGBRJPN
	Currency Currency	The currency code for the expense report's total amount.
Description This attribute specifies the currency in which the expense report's total amount is denominated, such as USD, EUR, or GBP. It is essential context for any financial data. When analyzing expenses from a global organization, this field is critical for correct interpretation and aggregation of monetary values. Analysis may require converting all amounts to a single base currency to allow for meaningful comparisons across different regions. Why it matters Provides necessary context for monetary values, ensuring accurate financial analysis and enabling currency conversion for global reporting. Where to get This is a standard field on the expense report header in Coupa, typically found alongside the total amount field, often with a name like 'currency-code'. Examples USDEURGBPJPY
	Expense Category ExpenseCategory	The category of the expense, such as travel, meals, or office supplies.
Description This attribute classifies the type of expense being claimed. Expense reports often contain multiple expense lines, each with its own category. For case-level analysis, this could be the most frequent category or an aggregated list. Segmenting the process by expense category can reveal different behaviors or bottlenecks. For example, travel expenses might follow a more complex approval path than office supply purchases. This dimension is key for understanding how the nature of the expense impacts its processing journey. Why it matters Allows for segmentation of the process based on the type of spend, which can reveal category-specific bottlenecks, policies, or approval paths. Where to get This information is stored at the expense line level in Coupa. For case-level analysis, it needs to be aggregated, for instance by taking the category of the highest-value line item. Examples AirfareMeals and EntertainmentSoftwareOffice Supplies
	Is First Pass Approval IsFirstPassApproval	A flag that is true if the expense report was approved without any rejections or revisions.
Description This is a case-level calculated attribute that indicates whether an expense report went through the approval process successfully on the first attempt. It is set to 'true' if the case does not contain any rejection or 'Sent Back For Revision' activities. This attribute directly measures the efficiency of the submission and approval process. It is the basis for the First-Pass Approval Rate KPI. Analyzing the factors that correlate with a low first-pass approval rate, such as department or expense category, can provide valuable insights for process improvement. Why it matters Provides a clear measure of process quality and efficiency, helping to quantify the percentage of reports that are processed without any rework. Where to get This is calculated at the case level. It requires scanning all activities for a given ExpenseReportId and checking for the absence of rejection or revision events. Examples truefalse
	Is Rework IsRework	A flag indicating if an activity is part of a rework loop, such as a report being sent back for revision.
Description This calculated boolean attribute flags activities that represent rework. It is typically set to 'true' for events like 'Sent Back For Revision' or for any activity that occurs after such an event within the same case. Identifying rework is a primary goal of process mining. This flag simplifies the analysis of rework by allowing direct filtering and aggregation. It is used to calculate the rework rate, visualize rework loops in the process map, and analyze the root causes of activities that force the process to repeat steps. Why it matters Directly flags inefficient rework loops, making it easy to quantify their frequency, impact on cycle time, and root causes. Where to get This is calculated based on the process flow. Logic needs to be applied to identify activities that signify a return to an earlier process stage, such as 'Sent Back For Revision'. Examples truefalse
	Policy Violation Reason PolicyViolationReason	The specific reason why an expense report was flagged for a policy violation.
Description When a policy violation is flagged, this attribute provides the specific reason for the flag, such as 'Amount exceeds limit' or 'Unapproved merchant'. This provides more detail than a simple boolean flag. Analyzing the reasons for policy violations gives a more granular understanding of compliance issues. It helps pinpoint specific policies that are frequently broken, which could indicate a need for better communication, policy adjustments, or stricter enforcement. This is key for creating effective compliance improvement strategies. Why it matters Provides specific details about compliance issues, allowing for targeted actions to improve adherence to company expense policies. Where to get This information is usually available in the details of the policy flag or warning message generated by Coupa's compliance engine. Examples Daily meal limit exceededExpense is a duplicateReceipt is required

Required Recommended Optional

Expense Management Activities

These are the key process steps and milestones to capture in your event log for accurate discovery and analysis of your expense workflow.

6 Recommended 7 Optional

	Activity	Description
	Accounting Posted	The financial transactions related to the expense report are posted to the General Ledger. This represents the final step in the process from a financial accounting perspective.
Why it matters This is the final activity, marking the true end of the process. The time from reimbursement to posting is critical for a fast and accurate financial close. Where to get This event is captured from the posting date of the journal entry or accounting lines associated with the expense report, which are managed by Coupa's accounting integration. Capture From the posting date field on the accounting lines related to the expense report. Event type explicit
	Expense Report Created	Marks the beginning of the expense report lifecycle. This event is captured when a user creates and saves a new expense report for the first time, establishing it in a draft state.
Why it matters This is the starting point for all process analysis and is crucial for measuring the total end-to-end cycle time of an expense report. Where to get This is an explicit event captured from the creation timestamp of the expense report header record in Coupa. The 'created_at' timestamp on the expense header table is the source. Capture Use the creation timestamp of the expense report object. Event type explicit
	Expense Report Submitted	The employee formally submits the completed expense report for approval. This action transitions the report from a draft state to a pending approval state and is explicitly logged by the system.
Why it matters This is a critical milestone that starts the approval clock. The duration between creation and submission indicates how long employees take to prepare reports. Where to get Captured from the submission timestamp on the expense report record itself or from the audit trail log entry for the submission event. Capture Use the 'submitted_at' timestamp field on the expense report. Event type explicit
	Finance Approved	The finance or audit team gives the final approval for the expense report. This event signals that the report is validated and ready for payment processing and is logged in the approval history.
Why it matters This is the final approval milestone. The time from manager approval to finance approval is a key component of the overall approval cycle. Where to get Captured from the timestamp of the final approval action in the expense report's detailed approval history or audit trail. Capture From the final approval event timestamp in the expense report's approval history. Event type explicit
	Manager Approved	The employee's direct manager or first-level approver approves the expense report. This is captured as an explicit event in the report's approval history, which includes a timestamp.
Why it matters Marks the completion of the first approval level. Analyzing the time to this event is key for the Approval Cycle Time KPI and identifying manager-level bottlenecks. Where to get Captured from the timestamp of the approval action in Coupa's detailed approval history or audit trail for the expense report. Capture From the approval event timestamp in the expense report's approval history log. Event type explicit
	Reimbursement Executed	The payment is successfully processed, and funds are disbursed to the employee. This event confirms that the employee has been paid and completes the reimbursement part of the process.
Why it matters This is a critical milestone for employee satisfaction and is the endpoint for the Average Reimbursement Lead Time KPI. Where to get Captured from the payment execution date on the payment record associated with the expense report, typically within Coupa Pay or an integrated AP system. Capture From the payment date on the associated payment record linked to the expense report. Event type explicit
	Expense Report Withdrawn	The employee withdraws a submitted expense report before it has been fully approved. This action cancels the current approval process and is captured as an explicit event.
Why it matters Tracks instances where employees self-correct or cancel submissions, which can indicate confusion about the process. It is a form of process interruption. Where to get Captured from an explicit user action, resulting in a 'Withdrawn' or 'Cancelled' status and recorded in the audit trail. Capture From the timestamp of the 'withdraw' action in the expense report's audit trail. Event type explicit
	Finance Rejected	The finance or audit team rejects the expense report, which is a terminal negative outcome. This is captured as a final rejection status in the report's history.
Why it matters Tracking finance rejections helps identify serious compliance or documentation issues that may have been missed by earlier reviews, impacting the rejection rate KPI. Where to get Captured from the timestamp of the rejection action by a finance approver in the expense report's audit trail. Capture From the rejection event timestamp in the audit trail during the finance review step. Event type explicit
	Manager Rejected	The employee's manager rejects the expense report, which often stops the process and returns the report to the employee. This is captured as a specific event in the approval history.
Why it matters This is a negative outcome that highlights process friction. Analyzing these events is crucial for the Expense Report Rejection Rate dashboard and KPI. Where to get Captured from the timestamp of the rejection action in the expense report's approval history or audit trail. Capture From the rejection event timestamp in the expense report's approval history log. Event type explicit
	Policy Check Performed	An automated check for compliance with company expense policies is executed. This is typically inferred from the timestamp when a policy violation flag or warning is first set on the report.
Why it matters Essential for the Policy Compliance Overview dashboard. It helps understand if and when violations are detected in the process, and their impact on approval times. Where to get Inferred from the timestamp associated with a policy violation flag being applied to an expense line or the report header. Capture Timestamp when a policy violation flag is first set on the expense report or its lines. Event type inferred
	Receipts Attached	Represents the user action of uploading or attaching receipts to an expense line within the report. This is captured by observing the creation of attachment records linked to the expense report.
Why it matters Analyzing the timing and frequency of this activity can reveal user behavior patterns and potential delays caused by missing documentation. Where to get Inferred from the creation timestamp of attachment records that are linked to the specific Expense Report ID. Capture Identify timestamps when attachment records are linked to the expense report. Event type inferred
	Reimbursement Scheduled	After final approval, the expense report is grouped into a payment batch to be paid. This marks the transition from the approval phase to the payment processing phase.
Why it matters This activity starts the clock for the Reimbursement Execution Cycle Time. Delays here indicate backlogs in moving approved reports to the payment system. Where to get Inferred from a status change to 'Pending Payment' or the date the report is associated with a payment batch record in Coupa Pay. Capture Timestamp when status changes to 'Pending Payment' or from the creation date of the related payment batch. Event type inferred
	Sent Back For Revision	An approver sends the report back to the employee for corrections without issuing a final rejection. This action creates a rework loop and is inferred from a status change or a specific audit trail event.
Why it matters This activity is the cornerstone for analyzing rework loops. Identifying why reports are sent back helps improve training and first-pass approval rates. Where to get Inferred from a status change to a state like 'Pending Correction' or 'Sent Back'. Coupa may also log this action explicitly in its approval history. Capture Timestamp of status change to a 'needs revision' state, or a specific event from the audit log. Event type inferred

Recommended Optional

Extraction Guides

How to get your data from Coupa Expenses

Steps

Prerequisites: Ensure you have a user account in Coupa with the necessary permissions, typically an Administrator or Integration Specialist role, to access and configure scheduled exports. You will also need access to an SFTP server where Coupa can deposit the exported files.
Navigate to Scheduled Exports: Log in to your Coupa instance. Go to the Setup menu, and under the Integrations section, click on Scheduled Exports.
Configure Expense Report Export: Click the 'Create' button. Configure the first export for the 'Expense Report' object. Give it a descriptive name like 'ProcessMind_Expense_Reports'. Select 'CSV' as the format. In the 'Fields' section, select columns such as id, created-at, submitted-at, updated-at, status, total, user-id, and any other relevant report-level attributes.
Configure Approval History Export: Create a second scheduled export for the 'Expense Report Approval' object. Name it 'ProcessMind_Expense_Approvals'. Include fields like id, created-at, updated-at, status, approver-id, and expense-report-id. This object is critical for capturing approval, rejection, and revision events.
Configure Attachment Export: Create a third export for the 'Expense Report Attachment' object, named 'ProcessMind_Expense_Attachments'. Include the created-at timestamp and the associated expense-report-id or expense-line-id to track when receipts are added.
Configure Invoice Export for Payments: Create a fourth export for the 'Invoice from Expense Report' object. Name it 'ProcessMind_Expense_Invoices'. This is required to track reimbursement and accounting events. Include fields like expense-report-id, paid-date, scheduled-payment-date, exported, and updated-at.
Set Delivery and Schedule: For each of the exports created, navigate to the 'Delivery' tab. Enter the connection details for your SFTP server, including the host, username, and directory path. Set the authentication method, typically password or key based. Under the 'Schedule' tab, set the frequency to 'Daily' to get regular updates.
Run and Ingest Exports: Activate the schedules and manually run them for the first time if needed. Set up an automated process, such as an ETL script or a data warehouse ingestion tool, to retrieve the CSV files from the SFTP server and load them into a staging database.
Transform Data into Event Log: Execute a transformation script, like the provided SQL query, against the staged data. This script unions the data from the different tables (reports, approvals, invoices) to create a single, unified event log table.
Export for ProcessMind: Export the resulting event log table from your database or data warehouse into a single CSV file. Ensure the column headers match the required attributes, such as ExpenseReportId, ActivityName, and EventTime. The file is now ready for upload into the process mining tool.

Configuration

Prerequisites: An active Coupa Expenses module is required. The user configuring the exports must have a role with permissions for 'Scheduled CSV Exports'. An SFTP server must be available and its IP address whitelisted if necessary.
Key Coupa Objects: The extraction relies on scheduling exports for several standard Coupa data objects: 'Expense Report', 'Expense Report Approval', 'Expense Report Attachment', and 'Invoice from Expense Report'.
SFTP Configuration: You must provide the SFTP server URL, port (usually 22), a dedicated user credential, and the target directory for the file drop. Ensure the connection is tested successfully within the Coupa UI.
Date Range and Filtering: Scheduled exports are typically configured to export records that have been created or updated since the last successful run. For the initial historical load, you can set a specific 'created-at' or 'updated-at' date range covering the desired period, such as the last 6 to 12 months.
File Format: Always use CSV as the file format for its simplicity and broad compatibility with data processing tools.
Scheduling Frequency: A daily export schedule is recommended for process mining to ensure the process data is kept reasonably up to date. Running it during off-peak hours can help minimize any potential performance impact.

a Sample Query config

WITH last_update AS (
  SELECT CURRENT_TIMESTAMP AS last_data_update
)
SELECT
  er.id AS ExpenseReportId,
  'Expense Report Created' AS ActivityName,
  er."created-at" AS EventTime,
  er."updated-at" AS EndTime,
  u.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_reports er
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu

UNION ALL

SELECT
  er.id AS ExpenseReportId,
  'Receipts Attached' AS ActivityName,
  att."created-at" AS EventTime,
  att."updated-at" AS EndTime,
  u.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_attachments att
JOIN stg_expense_reports er ON att.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu

UNION ALL

SELECT
  er.id AS ExpenseReportId,
  'Expense Report Submitted' AS ActivityName,
  er."submitted-at" AS EventTime,
  er."updated-at" AS EndTime,
  u.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_reports er
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE er."submitted-at" IS NOT NULL

UNION ALL

SELECT
  era.expense_report_id AS ExpenseReportId,
  'Manager Approved' AS ActivityName,
  era."updated-at" AS EventTime,
  era."updated-at" AS EndTime,
  approver.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_approvals era
JOIN stg_expense_reports er ON era.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
LEFT JOIN stg_users approver ON era.approver_id = approver.id
CROSS JOIN last_update lu
WHERE era.status = 'approved' AND approver.role LIKE '%Manager%'

UNION ALL

SELECT
  era.expense_report_id AS ExpenseReportId,
  'Manager Rejected' AS ActivityName,
  era."updated-at" AS EventTime,
  era."updated-at" AS EndTime,
  approver.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  era.reason AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_approvals era
JOIN stg_expense_reports er ON era.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
LEFT JOIN stg_users approver ON era.approver_id = approver.id
CROSS JOIN last_update lu
WHERE era.status = 'rejected' AND approver.role LIKE '%Manager%'

UNION ALL

SELECT
  era.expense_report_id AS ExpenseReportId,
  'Sent Back For Revision' AS ActivityName,
  era."updated-at" AS EventTime,
  era."updated-at" AS EndTime,
  approver.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  era.reason AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_approvals era
JOIN stg_expense_reports er ON era.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
LEFT JOIN stg_users approver ON era.approver_id = approver.id
CROSS JOIN last_update lu
WHERE era.status = 'sent_back'

UNION ALL

SELECT
  er.id AS ExpenseReportId,
  'Policy Check Performed' AS ActivityName,
  er."updated-at" AS EventTime,
  er."updated-at" AS EndTime,
  'System' AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_reports er
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE er.has_policy_violations = TRUE

UNION ALL

SELECT
  era.expense_report_id AS ExpenseReportId,
  'Finance Approved' AS ActivityName,
  era."updated-at" AS EventTime,
  era."updated-at" AS EndTime,
  approver.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_approvals era
JOIN stg_expense_reports er ON era.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
LEFT JOIN stg_users approver ON era.approver_id = approver.id
CROSS JOIN last_update lu
WHERE era.status = 'approved' AND approver.role LIKE '%Finance%'

UNION ALL

SELECT
  era.expense_report_id AS ExpenseReportId,
  'Finance Rejected' AS ActivityName,
  era."updated-at" AS EventTime,
  era."updated-at" AS EndTime,
  approver.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  era.reason AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_report_approvals era
JOIN stg_expense_reports er ON era.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
LEFT JOIN stg_users approver ON era.approver_id = approver.id
CROSS JOIN last_update lu
WHERE era.status = 'rejected' AND approver.role LIKE '%Finance%'

UNION ALL

SELECT
  er.id AS ExpenseReportId,
  'Expense Report Withdrawn' AS ActivityName,
  er."updated-at" AS EventTime,
  er."updated-at" AS EndTime,
  u.full_name AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_expense_reports er
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE er.status = 'withdrawn'

UNION ALL

SELECT
  inv.expense_report_id AS ExpenseReportId,
  'Reimbursement Scheduled' AS ActivityName,
  inv.scheduled_payment_date AS EventTime,
  inv.updated_at AS EndTime,
  'System' AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_invoices_from_expense_reports inv
JOIN stg_expense_reports er ON inv.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE inv.scheduled_payment_date IS NOT NULL

UNION ALL

SELECT
  inv.expense_report_id AS ExpenseReportId,
  'Reimbursement Executed' AS ActivityName,
  inv.paid_date AS EventTime,
  inv.updated_at AS EndTime,
  'System' AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_invoices_from_expense_reports inv
JOIN stg_expense_reports er ON inv.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE inv.paid_date IS NOT NULL

UNION ALL

SELECT
  inv.expense_report_id AS ExpenseReportId,
  'Accounting Posted' AS ActivityName,
  inv.updated_at AS EventTime,
  inv.updated_at AS EndTime,
  'System' AS UserName,
  u.department_name AS EmployeeDepartment,
  er.total AS TotalAmount,
  er.status AS ExpenseReportStatus,
  NULL AS RejectionReason,
  er.has_policy_violations AS PolicyViolationFlag,
  'Coupa' AS SourceSystem,
  lu.last_data_update AS LastDataUpdate
FROM stg_invoices_from_expense_reports inv
JOIN stg_expense_reports er ON inv.expense_report_id = er.id
LEFT JOIN stg_users u ON er.user_id = u.id
CROSS JOIN last_update lu
WHERE inv.exported = TRUE;

Steps

Prerequisites and Environment Setup: Ensure you have Python 3.6 or later installed. Install the necessary libraries, pandas for data manipulation and requests for making API calls, by running pip install pandas requests in your terminal. You must also obtain an API key from your Coupa administrator with read permissions for expense reports, expense lines, attachments, and approvals.
Generate Coupa API Key: Log in to your Coupa instance. Navigate to Setup > Company Setup > API Keys. Create a new API key, ensuring it has read permissions for the required Expense modules. Securely store this key as it provides access to your company's data.
Initialize the Python Script: Create a new Python file. Begin by importing the required libraries (requests, pandas, datetime). Define global constants for your Coupa instance URL (e.g., https://[your_company].coupahost.com), your API key, and the headers required for API authentication.
Define Date Range and API Parameters: Specify the start and end dates for the data extraction period. These will be used as filters in the API calls to limit the data volume. Also, define the pagination limit, which is typically 50 records per request for Coupa.
Fetch Expense Report Headers: Implement a function to retrieve all expense report headers within the specified date range. This function should handle pagination by making repeated calls to the /api/expense_reports endpoint, incrementing the offset parameter until all reports are fetched. Store these report headers in a list.
Iterate and Fetch Detailed Data: Loop through each expense report header obtained in the previous step. For each report, make separate API calls to fetch its associated details: approvals from /api/expense_reports/{id}/approvals and attachments from /api/expense_reports/{id}/attachments. These details are crucial for constructing the full event log.
Construct the Event Log: Initialize an empty list to hold your event log records. As you process each expense report and its detailed data, transform the raw API responses into standardized event log rows. For each of the 13 required activities, create a dictionary representing a single event and append it to the list. For example, use the created-at field for the 'Expense Report Created' event and loop through the approvals data to create 'Manager Approved' or 'Finance Rejected' events.
Map API Data to Attributes: In your transformation logic, map the JSON fields from the Coupa API responses to the required and recommended attributes. For instance, map id to ExpenseReportId, created-at to EventTime, and total to TotalAmount. Extract user and department information from the nested user objects.
Handle Inferred Events: Some activities, like 'Reimbursement Scheduled' or 'Accounting Posted', are inferred from status changes. Use the report's status field and the updated-at timestamp to generate these events. For example, a change to status 'processing_payment' can be logged as the 'Reimbursement Scheduled' activity.
Create and Export the DataFrame: Once you have processed all expense reports and populated the list of events, convert this list into a pandas DataFrame. Add static columns like SourceSystem and LastDataUpdate. Finally, export the DataFrame to a CSV file using the to_csv method, ensuring the index is set to False. This CSV file is now ready for upload to ProcessMind.

Configuration

API Key Permissions: The API key used for authentication must have at least read-only access to the following Coupa objects: Expense Reports, Expense Lines, Users, Approvals, and Attachments.
Coupa Instance URL: You must provide the base URL for your company's Coupa instance (e.g., https://your-company.coupahost.com). This is the root for all API endpoint calls.
Date Range Filters: It is critical to filter the data by a specific period to manage performance and data volume. Use the created-at[gt] (greater than) and created-at[lt] (less than) query parameters. A typical starting range is 3-6 months of data.
Pagination Limit: The Coupa API limits the number of records returned in a single request, typically to 50. The script must be configured to handle this limit and use the offset parameter to retrieve all subsequent pages of data.
Status Filters: To further narrow down the extraction scope, you can add a status filter to the initial query for expense report headers. For example, you might only extract reports with a status of 'approved', 'paid', or 'denied'.
Performance Considerations: The script makes multiple API calls for each expense report. For instances with tens of thousands of reports, the extraction can be time-consuming. Consider running the script during off-peak hours or implementing an incremental load strategy based on the updated-at timestamp.

a Sample Query python

import requests
import pandas as pd
import datetime
import time

class=class="hl-string">"hl-comment"># --- Configuration Settings ---
class=class="hl-string">"hl-comment"># Replace with your Coupa instance URL and API Key
COUPA_URL = class="hl-string">"https://[your_company].coupahost.com"
API_KEY = class="hl-string">"[your_api_key]"

class=class="hl-string">"hl-comment"># Define the date range for the extraction
class=class="hl-string">"hl-comment"># Format: YYYY-MM-DDTHH:MM:SSZ (UTC)
START_DATE = class="hl-string">"2023-01-01T00:00:00Z"
END_DATE = class="hl-string">"2023-12-31T23:59:59Z"

class=class="hl-string">"hl-comment"># API request headers
HEADERS = {
    class="hl-string">"Accept": class="hl-string">"application/json",
    class="hl-string">"X-COUPA-API-KEY": API_KEY
}

class=class="hl-string">"hl-comment"># Static values for the event log
SOURCE_SYSTEM = class="hl-string">"Coupa Expenses"
LAST_DATA_UPDATE = datetime.datetime.utcnow().isoformat() + class="hl-string">'Z'

def get_paginated_data(endpoint, params):
    class="hl-string">"""Helper function to fetch all pages for a given API endpoint."""
    all_data = []
    offset = 0
    limit = 50
    while True:
        params[class="hl-string">'offset'] = offset
        params[class="hl-string">'limit'] = limit
        try:
            response = requests.get(endpoint, headers=HEADERS, params=params)
            response.raise_for_status() class=class="hl-string">"hl-comment"># Raises an HTTPError for bad responses (4xx or 5xx)
            data = response.json()
            if not data:
                break
            all_data.extend(data)
            offset += limit
        except requests.exceptions.RequestException as e:
            print(fclass="hl-string">"Error fetching data from {endpoint}: {e}")
            break
    return all_data

def main():
    class="hl-string">"""Main function to extract, transform, and save expense data."""
    print(class="hl-string">"Starting expense report extraction...")
    event_log = []

    class=class="hl-string">"hl-comment"># 1. Fetch all expense report headers in the date range
    reports_endpoint = fclass="hl-string">"{COUPA_URL}/api/expense_reports"
    reports_params = {
        class="hl-string">"created-at[gt]": START_DATE,
        class="hl-string">"created-at[lt]": END_DATE,
        class="hl-string">"fields": class="hl-string">"["idclass="hl-string">", "created-atclass="hl-string">", "updated-atclass="hl-string">", "submitted-atclass="hl-string">", "withdrawn-atclass="hl-string">", "statusclass="hl-string">", "totalclass="hl-string">", "userclass="hl-string">", "exportedclass="hl-string">", "expense-linesclass="hl-string">", "policy-violationsclass="hl-string">"]"
    }
    expense_reports = get_paginated_data(reports_endpoint, reports_params)

    print(fclass="hl-string">"Found {len(expense_reports)} expense reports to process.")

    class=class="hl-string">"hl-comment"># 2. Process each expense report to create events
    for i, report in enumerate(expense_reports):
        print(fclass="hl-string">"Processing report {i+1}/{len(expense_reports)}: ID {report['id']}")
        
        class=class="hl-string">"hl-comment"># Common attributes for all events of this case
        base_event = {
            class="hl-string">'ExpenseReportId': report[class="hl-string">'id'],
            class="hl-string">'TotalAmount': float(report.get(class="hl-string">'total', 0.0)),
            class="hl-string">'ExpenseReportStatus': report.get(class="hl-string">'status'),
            class="hl-string">'EmployeeDepartment': report.get(class="hl-string">'user', {}).get(class="hl-string">'department', {}).get(class="hl-string">'name') if report.get(class="hl-string">'user', {}).get(class="hl-string">'department') else None,
            class="hl-string">'SourceSystem': SOURCE_SYSTEM,
            class="hl-string">'LastDataUpdate': LAST_DATA_UPDATE,
            class="hl-string">'EndTime': None, class=class="hl-string">"hl-comment"># EndTime can be populated if duration is meaningful
            class="hl-string">'RejectionReason': None, class=class="hl-string">"hl-comment"># Will be populated by rejection events
            class="hl-string">'PolicyViolationFlag': bool(report.get(class="hl-string">'policy-violations'))
        }

        class=class="hl-string">"hl-comment"># Event: Expense Report Created
        event_log.append({
            **base_event,
            class="hl-string">'ActivityName': class="hl-string">'Expense Report Created',
            class="hl-string">'EventTime': report[class="hl-string">'created-at'],
            class="hl-string">'UserName': report.get(class="hl-string">'user', {}).get(class="hl-string">'fullname')
        })
        
        class=class="hl-string">"hl-comment"># Event: Expense Report Submitted
        if report.get(class="hl-string">'submitted-at'):
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Expense Report Submitted',
                class="hl-string">'EventTime': report[class="hl-string">'submitted-at'],
                class="hl-string">'UserName': report.get(class="hl-string">'user', {}).get(class="hl-string">'fullname')
            })

        class=class="hl-string">"hl-comment"># Event: Expense Report Withdrawn
        if report.get(class="hl-string">'withdrawn-at'):
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Expense Report Withdrawn',
                class="hl-string">'EventTime': report[class="hl-string">'withdrawn-at'],
                class="hl-string">'UserName': report.get(class="hl-string">'user', {}).get(class="hl-string">'fullname')
            })
        
        class=class="hl-string">"hl-comment"># Event: Policy Check Performed (inferred)
        if base_event[class="hl-string">'PolicyViolationFlag']:
             event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Policy Check Performed',
                class="hl-string">'EventTime': report[class="hl-string">'updated-at'], class=class="hl-string">"hl-comment"># Using updated-at as a proxy timestamp
                class="hl-string">'UserName': class="hl-string">'System'
            })

        class=class="hl-string">"hl-comment"># 3. Fetch attachments for class="hl-string">'Receipts Attached' event
        attachments_endpoint = fclass="hl-string">"{COUPA_URL}/api/expense_reports/{report['id']}/attachments"
        attachments = get_paginated_data(attachments_endpoint, {})
        if attachments:
            first_attachment_time = min(att[class="hl-string">'created-at'] for att in attachments if class="hl-string">'created-at' in att)
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Receipts Attached',
                class="hl-string">'EventTime': first_attachment_time,
                class="hl-string">'UserName': report.get(class="hl-string">'user', {}).get(class="hl-string">'fullname')
            })

        class=class="hl-string">"hl-comment"># 4. Fetch approvals for approval/rejection events
        approvals_endpoint = fclass="hl-string">"{COUPA_URL}/api/expense_reports/{report['id']}/approvals"
        approvals = get_paginated_data(approvals_endpoint, {})
        
        is_first_approval = True
        for approval in sorted(approvals, key=lambda x: x[class="hl-string">'updated-at']):
            activity = None
            rejection_reason = approval.get(class="hl-string">'reason')
            
            if approval[class="hl-string">'status'] == class="hl-string">'approved':
                activity = class="hl-string">'Manager Approved' if is_first_approval else class="hl-string">'Finance Approved'
                is_first_approval = False
            elif approval[class="hl-string">'status'] == class="hl-string">'rejected':
                activity = class="hl-string">'Manager Rejected' if is_first_approval else class="hl-string">'Finance Rejected'
                is_first_approval = False
            elif approval[class="hl-string">'status'] in [class="hl-string">'sent_back', class="hl-string">'pending_resubmit']:
                activity = class="hl-string">'Sent Back For Revision'

            if activity:
                event_log.append({
                    **base_event,
                    class="hl-string">'ActivityName': activity,
                    class="hl-string">'EventTime': approval[class="hl-string">'updated-at'],
                    class="hl-string">'UserName': approval.get(class="hl-string">'approver', {}).get(class="hl-string">'fullname'),
                    class="hl-string">'RejectionReason': rejection_reason
                })
        
        class=class="hl-string">"hl-comment"># 5. Infer payment and accounting events from status
        if report[class="hl-string">'status'] == class="hl-string">'processing_payment':
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Reimbursement Scheduled',
                class="hl-string">'EventTime': report[class="hl-string">'updated-at'], class=class="hl-string">"hl-comment"># Inferred from last update timestamp
                class="hl-string">'UserName': class="hl-string">'System'
            })
            
        if report[class="hl-string">'status'] == class="hl-string">'paid':
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Reimbursement Executed',
                class="hl-string">'EventTime': report[class="hl-string">'updated-at'], class=class="hl-string">"hl-comment"># Inferred from last update timestamp
                class="hl-string">'UserName': class="hl-string">'System'
            })

        class=class="hl-string">"hl-comment"># class="hl-string">'exported' flag indicates posting to an ERP system
        if report.get(class="hl-string">'exported') == True:
            event_log.append({
                **base_event,
                class="hl-string">'ActivityName': class="hl-string">'Accounting Posted',
                class="hl-string">'EventTime': report[class="hl-string">'updated-at'], class=class="hl-string">"hl-comment"># Inferred from last update timestamp
                class="hl-string">'UserName': class="hl-string">'System'
            })

    class=class="hl-string">"hl-comment"># 6. Create DataFrame and save to CSV
    if not event_log:
        print(class="hl-string">"No events were generated. Exiting.")
        return
        
    df = pd.DataFrame(event_log)
    class=class="hl-string">"hl-comment"># Reorder columns for clarity
    column_order = [
        class="hl-string">'ExpenseReportId', class="hl-string">'ActivityName', class="hl-string">'EventTime', class="hl-string">'EndTime', class="hl-string">'UserName',
        class="hl-string">'EmployeeDepartment', class="hl-string">'TotalAmount', class="hl-string">'ExpenseReportStatus',
        class="hl-string">'RejectionReason', class="hl-string">'PolicyViolationFlag', class="hl-string">'SourceSystem', class="hl-string">'LastDataUpdate'
    ]
    df = df[column_order]
    df.sort_values(by=[class="hl-string">'ExpenseReportId', class="hl-string">'EventTime'], inplace=True)
    
    output_filename = class="hl-string">'coupa_expense_event_log.csv'
    df.to_csv(output_filename, index=False)
    print(fclass="hl-string">"Extraction complete. Event log saved to {output_filename}")

if __name__ == class="hl-string">"__main__":
    main()

Your Expense Management Data Template

Your Expense Management Data Template

Expense Management Attributes

Expense Management Activities

Extraction Guides

Coupa Scheduled Exports via SFTP for Expense Data

Steps

Configuration

a Sample Query config

Python Script using the Coupa REST API for Expenses

Steps

Configuration

a Sample Query python

Ready to Get Started?

Optimize Expense Management: Eliminate Bottlenecks Today

Your Expense Management Data Template

Your Expense Management Data Template

Expense Management Attributes

Expense Management Activities

Extraction Guides

Coupa Scheduled Exports via SFTP for Expense Data

Steps

Configuration

a Sample Query config

Python Script using the Coupa REST API for Expenses

Steps

Configuration

a Sample Query python

We value your privacy

Ready to Get Started?

Optimize Expense Management: Eliminate Bottlenecks Today