> Continuous Process Improvement > Accounts Payable Invoice Processing > SAP ECC > Data Template

Data Template: Accounts Payable Invoice Processing

SAP ECC

Accounts Payable Invoice Processing Attributes (22) Accounts Payable Invoice Processing Activities (13) Extraction Guides (4)

Your Accounts Payable Invoice Processing Data Template

This comprehensive data template provides the essential information needed to effectively analyze your Accounts Payable Invoice Processing. It outlines the crucial data attributes to collect, the key process activities to track, and practical guidance for extracting this data directly from your SAP ECC system. Use this template to ensure you capture all necessary details for a complete and insightful process analysis.

Recommended attributes to collect
Key activities to track
Extraction guidance

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

Download Template

Accounts Payable Invoice Processing Attributes

These are the recommended data fields to include in your event log for comprehensive analysis of your accounts payable invoice processing.

3 Required 9 Recommended 10 Optional

	Name	Description
	Activity Activity	The name of a specific business step or event that occurred within the invoice processing lifecycle.
Description This attribute describes a single task or status change in the Accounts Payable process, such as 'Invoice Parked', 'Invoice Routed For Approval', or 'Invoice Cleared By Payment'. These activities are the building blocks of the process map and are typically extracted from change logs, status fields, or workflow logs within SAP. Analyzing the sequence and duration of these activities is the core of process mining. It helps to visualize the process flow, identify bottlenecks between steps, measure the frequency of rework loops, and compare actual process execution against standard operating procedures. The granularity of activities defined directly impacts the depth of insights achievable. Why it matters Activities form the backbone of the process map, allowing for visualization of the process flow, identification of bottlenecks, and analysis of deviations. Where to get Derived from transaction codes (BKPF-TCODE), workflow logs (SWW_WI2OBJ), or change logs (CDHDR/CDPOS tables) based on changes to invoice documents. Examples Invoice Document CreatedInvoice ApprovedInvoice Cleared By PaymentPayment Block Set
	Event Time EventTime	The precise date and time when a specific activity or event occurred.
Description Event Time is the timestamp associated with each activity in the process. This data is critical for chronological ordering of events and for all time-based analysis. In SAP, this information is often stored in creation fields (e.g., BKPF-CPUDT) or change log tables (CDHDR-UDATE and CDHDR-UTIME). This attribute is essential for calculating key performance indicators such as cycle times, processing times, and waiting times between activities. It enables the analysis of process performance over time, helps identify when bottlenecks occur, and is used to check compliance with service level agreements (SLAs) or payment terms. Why it matters This timestamp is crucial for calculating all duration-based metrics, including cycle times and bottlenecks, forming the basis of performance analysis. Where to get From SAP tables like BKPF (CPUDT/CPUTM for creation) or CDHDR (UDATE/UTIME for changes). Examples 2023-10-01T10:00:00Z2023-10-02T14:35:10Z2023-10-15T09:12:00Z
	Invoice InvoiceNumber	The unique identifier for each invoice document, serving as the primary case identifier for tracking its journey from receipt to payment.
Description The Invoice Number is a composite key, typically formed by combining the Company Code (BUKRS), Document Number (BELNR), and Fiscal Year (GJAHR) in SAP. This unique combination ensures that every invoice is distinctly identified across the entire system. In process mining, this attribute is fundamental. It links all related events and activities, such as creation, posting, approval, and payment, into a single, cohesive process instance. Analyzing the process by Invoice allows for a complete end-to-end view of the invoice lifecycle, which is essential for calculating cycle times, identifying variants, and understanding rework loops. Why it matters It is the essential Case ID that connects all invoice-related activities, enabling a complete end-to-end analysis of the Accounts Payable process for each invoice. Where to get Constructed from SAP tables BKPF (Accounting Document Header) fields BUKRS, BELNR, and GJAHR. Examples 1000-1900000001-20232000-5100000055-20231000-1900000042-2024
	Approver Approver	The user or role responsible for approving the invoice for payment.
Description This attribute identifies the person who performed the 'Invoice Approved' activity. In SAP, this is often managed through the workflow system, and the approver's ID is logged in the workflow history. Analyzing by Approver is central to the 'Invoice Approval Bottleneck Analysis' dashboard. It helps measure approval times per individual or group, identify approvers who are consistently slow, and understand workload distribution within the approval hierarchy. This data is crucial for optimizing the approval workflow, which is often a major bottleneck. Why it matters Identifies the individual responsible for approvals, enabling analysis of approval cycle times and bottlenecks by person or team. Where to get Typically found in SAP Business Workflow tables (e.g., SWW_WI2OBJ, SWWLOG) by linking the workflow item to the invoice object and identifying the user of the approval step. Examples DMARTINLCHENFINMAN_ROLE
	Company Code CompanyCode	A unique key representing a legal entity or company within the SAP organization.
Description The Company Code is a fundamental organizational unit in SAP Financials, representing an independent accounting unit. All financial transactions, including invoices, are posted to a specific company code. This attribute is essential for segmenting the process analysis by legal entity. It allows for comparing process performance, compliance rates, and efficiency across different parts of the business. This is particularly important for large, multinational corporations with multiple subsidiaries. Why it matters Enables process analysis to be segmented by legal entity, allowing for performance comparison across different business units. Where to get From SAP table BKPF (Accounting Document Header) field BUKRS. Examples 10002100US01
	Invoice Due Date InvoiceDueDate	The calculated date by which the invoice payment is due according to the payment terms.
Description The Invoice Due Date indicates the deadline for paying the supplier to remain in compliance with agreed terms. In SAP, this is often not a single stored field but is calculated based on the document's baseline date (BSEG-ZFBDT) and the payment terms (BSEG-ZTERM) associated with the invoice. This date is critical for the 'Payment Compliance & Discounts' dashboard. It is used to calculate KPIs like the Overdue Payment Rate and to identify invoices at risk of late payment. Analyzing against this date helps prioritize workload and improve supplier relationships. Why it matters This is a critical date for monitoring payment compliance, calculating overdue KPIs, and capturing early payment discounts. Where to get Derived based on the Baseline Date for Due Date Calculation (BSEG-ZFBDT) and the Terms of Payment Key (BSEG-ZTERM). Examples 2023-10-312023-11-152024-01-10
	Invoice Gross Amount InvoiceGrossAmount	The total gross value of the invoice, including taxes and other charges, in the original document currency.
Description This attribute represents the total financial value of an invoice. It is a critical piece of data for understanding the financial impact and characteristics of the invoices being processed. In SAP, this amount can be found in various tables depending on the document type, such as BSEG for financial documents. In analysis, the invoice amount is used to prioritize high-value invoices, understand the financial throughput of the AP process, and segment analysis. For example, one could analyze if high-value invoices have longer cycle times or are subject to different approval paths. It's also fundamental for financial KPIs. Why it matters Provides financial context to the process, enabling value-based analysis, prioritization of high-value invoices, and calculation of financial KPIs. Where to get From SAP line item tables like BSEG field WRBTR (Amount in document currency). Calculation may be needed to aggregate line items to the header level. Examples 1500.0012550.75980.50
	Payment Block Reason PaymentBlockReason	A code indicating why an invoice is blocked from being paid.
Description When an invoice has a discrepancy or is under review, a payment block can be applied to prevent it from being included in a payment run. This attribute provides the reason for the block, such as a quantity mismatch or price variance. This information is vital for exception analysis. It helps categorize the root causes of payment delays and rework, supporting the 'Exception and Discrepancy Analysis' dashboard. Understanding the most frequent block reasons allows for targeted process improvements to reduce exceptions. Why it matters Provides the root cause for payment delays, enabling targeted analysis to reduce exceptions, rework, and invoice processing time. Where to get From SAP table BSEG (Accounting Document Segment) field ZLSPR. Examples RIA
	Payment Terms PaymentTerms	The code defining the conditions for payment, such as due dates and potential discounts.
Description Payment Terms are predefined rules in SAP that determine how invoice due dates and cash discounts are calculated. They are assigned to vendor masters and can be specified on individual invoices. This attribute is essential for the 'Payment Compliance & Discounts' dashboard and the 'Early Payment Discount Capture Rate' KPI. By analyzing the payment terms, a company can identify opportunities for capturing discounts, understand the financial implications of payment schedules, and ensure compliance. Why it matters Defines the rules for payment due dates and discounts, which is crucial for financial optimization and compliance monitoring. Where to get From SAP table BSEG (Accounting Document Segment) field ZTERM. Examples Z0010001NT30
	Processor User ProcessorUser	The SAP username of the employee who performed the activity, such as posting or changing the invoice.
Description This attribute identifies the individual user responsible for executing a specific process step. In SAP, this can be the user who created the document (e.g., BKPF-USNAM) or the user who made a specific change (e.g., CDHDR-USERNAME). Analyzing by Processor User is key to understanding team performance and workload distribution. It helps in building the 'AP Processor Workload Distribution' dashboard by tracking the volume of invoices and average activity times per user. This can reveal training needs, identify top performers, and support equitable task allocation. Why it matters Enables workload analysis, performance comparison between users, and identification of training opportunities or resource imbalances. Where to get From SAP table CDHDR field USERNAME (for changes) or BKPF field USNAM (for document entry). Examples AJONESSMITHBCWILLIAMS
	Purchase Order Number PurchaseOrderNumber	The identifier for the purchase order against which the invoice is being billed.
Description The Purchase Order (PO) Number links the invoice to the procurement process. For PO-backed invoices, this connection is critical for the three-way match between the PO, Goods Receipt, and Invoice. This attribute is key for the 'PO/GR Matching Performance' dashboard. Analyzing the presence and matching of a PO helps distinguish between different invoice types (PO vs. non-PO) and measure the efficiency of the matching process. Delays in this area are a common source of process bottlenecks. Why it matters Links the invoice to the procurement process, enabling analysis of PO vs. non-PO invoices and the efficiency of the three-way matching process. Where to get From SAP table BSEG (for FI invoices) or RSEG (for MM invoices) field EBELN. Examples 450001712345000175894500018330
	Vendor Name VendorName	The name of the vendor or supplier who submitted the invoice.
Description This attribute contains the official name of the supplier. In SAP, the vendor master data (table LFA1) is linked to the invoice document via the vendor number (LIFNR) stored in the document header or line items. Analyzing by vendor is crucial for the 'Vendor Payment Performance' dashboard. It allows for tracking invoice processing times, payment timeliness, and exception rates for specific suppliers. These insights can help manage supplier relationships, identify problematic vendors with consistently poor invoice quality, and negotiate better terms. Why it matters Allows for vendor-specific performance analysis, helping to manage supplier relationships and identify issues tied to particular vendors. Where to get From SAP table LFA1 field NAME1, linked via the vendor number (LIFNR) found in BKPF or BSEG. Examples Global Office Supplies Inc.Tech Solutions LLCReliable Logistics Corp.
	Discount Lost DiscountLost	A calculated flag that is true if an available early payment discount was not taken.
Description This attribute identifies invoices where the payment terms offered a discount for early payment, but the payment was made after the discount period expired. It is calculated by comparing the payment date against the discount due date derived from the 'Payment Terms'. This is a critical financial KPI for the 'Early Payment Discount Capture Rate'. It highlights missed opportunities to reduce costs. Analyzing why discounts are lost (e.g., long approval cycles, payment blocks) can justify process improvement projects with a clear return on investment. Why it matters Highlights missed financial opportunities, directly supporting the 'Early Payment Discount Capture Rate' KPI and providing a clear monetary incentive for process improvement. Where to get Calculated field: TRUE if (Payment Terms offered a discount) AND (Payment Date > Discount Due Date), otherwise FALSE. Examples truefalse
	Document Currency DocumentCurrency	The currency code (e.g., USD, EUR) in which the invoice was issued.
Description This attribute specifies the currency of the invoice amount. It is stored at the document header level in SAP. Document Currency is essential for any financial analysis to ensure amounts are interpreted correctly. It allows for filtering the process analysis by currency and is a prerequisite for converting amounts to a common local currency for standardized reporting and aggregation. Why it matters Provides necessary context for interpreting financial amounts and allows for currency-specific analysis or conversion to a standard currency. Where to get From SAP table BKPF (Accounting Document Header) field WAERS. Examples USDEURGBP
	Document Type DocumentType	A code in SAP that classifies accounting documents and controls how they are processed.
Description The Document Type differentiates various business transactions, such as vendor invoices (KR), credit memos (KG), or MM invoices (RE). This classification governs aspects like the number range and the types of accounts that can be posted to. In process mining, filtering by Document Type allows for a more homogenous analysis. For example, the process for a standard vendor invoice (KR) may differ significantly from that of a credit memo (KG). Analyzing these separately prevents misleading aggregations and provides more accurate insights into specific subprocesses. Why it matters Allows for the segmentation of analysis by transaction type (e.g., invoice vs. credit memo), leading to more accurate and relevant process insights. Where to get From SAP table BKPF (Accounting Document Header) field BLART. Examples KRREKG
	Goods Receipt Number GoodsReceiptNumber	The identifier for the goods receipt document related to a PO-based invoice.
Description For invoices related to physical goods, the Goods Receipt (GR) document confirms the delivery of items from a vendor. This number links the invoice to the specific delivery event. This attribute is used in the 'PO/GR Matching Performance' dashboard. The time between GR posting and invoice posting is a key metric. Analyzing this link helps understand the complete three-way matching process and identify delays between the physical delivery and financial settlement. Why it matters Completes the three-way match picture (PO-GR-Invoice), allowing for analysis of delays between goods delivery and invoice processing. Where to get From SAP table RSEG (Document Item, Incoming Invoice) field LFBNR (Document No. of a Reference Document). Examples 500000123450000015675000002100
	Invoice Processing Time InvoiceProcessingTime	The total time elapsed from the first activity (e.g., invoice creation) to the final activity (e.g., payment).
Description This is a calculated metric that measures the end-to-end cycle time for each individual invoice. It is derived by taking the timestamp of the last event and subtracting the timestamp of the first event for a given case (Invoice Number). This attribute is the primary KPI for the 'End-to-End Invoice Cycle Time' dashboard. It provides a high-level measure of overall process efficiency. Analyzing its average, median, and distribution helps to identify trends, measure the impact of process improvements, and set performance targets. Why it matters This is a primary KPI measuring overall process efficiency. Tracking it helps identify the impact of improvement initiatives on the end-to-end lifecycle. Where to get Calculated field: (Timestamp of the last event for the case) - (Timestamp of the first event for the case). Examples 10 days 2 hours 15 minutes5 days 0 hours 0 minutes22 days 8 hours 30 minutes
	Is Automated IsAutomated	A flag indicating if an activity was performed by a system or batch user versus a human user.
Description This boolean attribute distinguishes between activities performed automatically (e.g., by a batch job, EDI, or OCR system) and those performed manually by a user. This is typically determined by analyzing the username associated with an activity. This is fundamental for the 'Manual vs. Automated Processing' dashboard. It helps measure the success of automation initiatives, calculate the Manual Intervention Rate KPI, and identify remaining opportunities to reduce manual effort. Understanding the human vs. system touchpoints is key to driving efficiency. Why it matters Helps to measure the level of automation in the process, identify manual bottlenecks, and track the impact of automation initiatives. Where to get Derived by checking if the user ID (e.g., CDHDR-USERNAME) belongs to a predefined list of system, batch, or service accounts. Examples truefalse
	Is Overdue IsOverdue	A calculated flag that is true if the invoice was paid after its scheduled due date.
Description This boolean attribute is derived by comparing the date of the 'Invoice Cleared By Payment' activity with the 'Invoice Due Date'. If the payment date is after the due date, the flag is set to true. This attribute directly supports the 'Overdue Payment Rate' KPI and the 'Payment Compliance & Discounts' dashboard. It allows for easy filtering and counting of late payments, helping to quantify the scale of the problem. Analyzing the characteristics of overdue invoices (e.g., by vendor, company code) can reveal root causes. Why it matters Directly measures payment-term compliance and is the basis for the Overdue Payment Rate KPI, helping to improve supplier relationships and avoid penalties. Where to get Calculated field: TRUE if (Payment Date > Invoice Due Date), otherwise FALSE. Examples truefalse
	Is Reversed IsReversed	A boolean flag indicating if the invoice document was reversed.
Description This attribute flags invoices that have been cancelled or reversed, which is a significant event indicating a serious error or process failure. In SAP, a reversed document is linked to a reversal document. Identifying reversed invoices is important for understanding process quality and failure rates. It helps to isolate these terminal exceptions from the main process flow and allows for a dedicated root cause analysis to understand why reversals are happening and how to prevent them. Why it matters Flags invoices that were cancelled, which is a key indicator of process failure and helps in analyzing the root causes of major errors. Where to get Check if the document number (BKPF-BELNR) exists in the BKPF-STBLG (Reversal document) field for any other document. Examples truefalse
	Last Data Update LastDataUpdate	The timestamp indicating when the data for this record was last refreshed from the source system.
Description This attribute marks the date and time of the most recent data extraction or update from SAP ECC. It is not part of the transactional data itself but is metadata added during the data ingestion process. Its primary use in analysis is to provide context on the freshness of the data being viewed. This is crucial for dashboards and reports, as it informs users how up-to-date their analysis is and helps manage expectations about the inclusion of very recent transactions. Why it matters Indicates the freshness of the dataset, which is critical for understanding the timeliness of the process insights and dashboards. Where to get This is metadata generated and added during the data extraction, transformation, and loading (ETL) process. Examples 2024-05-21T02:00:00Z2024-05-22T02:00:00Z2024-05-23T02:00:00Z
	Source System SourceSystem	Identifies the source SAP ECC system from which the data was extracted.
Description This attribute specifies the system of record, such as the SAP System ID (SID), where the invoice processing data originated. It is particularly important in organizations with multiple ERP instances or a mix of systems. In a process mining analysis, it helps differentiate data from different systems, which may have unique configurations or process variations. This allows for comparative analysis between systems and ensures data lineage is clear, which is vital for data governance and validation. Why it matters Ensures data traceability and allows for process analysis in environments with multiple SAP instances or other source systems. Where to get Typically a static value representing the SAP System ID (SID) of the source ECC instance, added during the data extraction process. Examples ECC_PROD_EUSAP_US_01E5P

Required Recommended Optional

Accounts Payable Invoice Processing Activities

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

6 Recommended 7 Optional

	Activity	Description
	Invoice Approved	A designated approver has confirmed the invoice is valid and ready for payment. This can be an explicit event from a workflow system or inferred from the removal of a payment block. It is a critical milestone before payment.
Why it matters This is a key milestone that unblocks the invoice for payment. Delays before or after this step indicate different types of problems, such as approver availability or payment run scheduling issues. Where to get In a workflow system, this is an explicit event. Otherwise, it is commonly inferred from the removal of a payment block, captured via change logs (CDHDR/CDPOS) for the BSEG-ZLSPR field. Capture Event from workflow system or change log for removal of payment block. Event type explicit
	Invoice Cleared By Payment	The invoice is fully paid and the open item is cleared against a payment document. This marks the successful completion of the Accounts Payable process for the invoice. This is captured by the clearing document information.
Why it matters This is the primary success-path end event. The time to reach this activity is a key measure of overall process efficiency. It is also essential for calculating payment timeliness and discount capture. Where to get This event is identified when the Clearing Document Number (BSEG-AUGBL) and Clearing Date (BSEG-AUGDT) are populated for the vendor line item. The clearing date is the timestamp of the event. Capture Use the Clearing Date (BSEG.AUGDT) when the Clearing Document (BSEG.AUGBL) is populated. Event type explicit
	Invoice Document Created	Marks the initial creation of an invoice document in SAP, either as a parked or fully posted document. This is typically the first timestamped event for an invoice and serves as the starting point for process analysis. It is captured from the document entry date and time in the BKPF table.
Why it matters This activity is the primary start event for the invoice processing journey. Analyzing the time from this point helps measure the total end-to-end cycle time and identify initial data entry delays. Where to get This event is inferred from the creation timestamp of the accounting document header record. Specifically, the combination of Entry Date (BKPF-CPUDT) and Entry Time (BKPF-CPUTM) provides the timestamp. Capture Use creation timestamp from document header table BKPF (CPUDT, CPUTM). Event type inferred
	Invoice Posted	The invoice is formally recorded in the General Ledger, creating a financial liability. A parked document is converted to a posted document, or it is created as posted from the start. This is a fundamental step in financial accounting.
Why it matters Posting is a critical milestone that makes the invoice an official liability. It separates the data entry phase from the active payment management phase of the process. Where to get Identified from the document header table BKPF. A posted document has a blank Document Status (BKPF-BSTAT) and a valid Posting Date (BKPF-BUDAT). The event timestamp is the posting date. Capture Use BKPF.BUDAT for documents where BKPF.BSTAT is not 'V' (Parked) or 'V' has been changed. Event type explicit
	Invoice Reversed	The posted invoice document has been cancelled by creating a reversal document. This action nullifies the financial impact of the original invoice. This represents an alternative, often negative, end to the process.
Why it matters Reversals indicate errors, such as incorrect data entry or duplicate invoices. Tracking the frequency and reasons for reversals helps identify opportunities for improving data quality and first-time-right processing. Where to get This event is identified from the document header table (BKPF). The original document will have the Reversal Document number (BKPF-STBLG) populated. The event time is the posting date of the reversal document. Capture Find reversal document in BKPF.STBLG; get timestamp from the reversal document's posting date. Event type explicit
	Payment Proposal Created	The invoice has been included in a payment proposal list as part of a payment run (T-Code F110). While not a final payment, it indicates the intent to pay. The invoice is selected based on its due date and payment terms.
Why it matters This is the first step in the automated payment process. Delays between proposal and final payment execution can indicate issues with the payment run approval or scheduling. Where to get This event is identified by finding the invoice document in the payment proposal tables, such as REGUP (Processed Items from Payment Program). The run date (REGUP-LAUFD) can be used as the event time. Capture Find invoice in REGUP table and use the payment run date (LAUFD). Event type explicit
	Due Date Passed Without Payment	This calculated event occurs when the current date surpasses the invoice's net due date, but the invoice has not yet been cleared. It highlights invoices that are at risk of becoming or already are overdue. This is not a direct system event.
Why it matters This activity is crucial for monitoring the Overdue Payment Rate KPI. It proactively flags invoices that require immediate attention to avoid late payment fees and damaged vendor relationships. Where to get This is a calculated event. It's derived by comparing the current date to the Net Due Date (BSEG-ZFBDT) for all open (un-cleared) invoice items. The event timestamp is the due date itself. Capture Derive by comparing current date with BSEG.ZFBDT for open items. Event type calculated
	Goods Receipt Matched	Represents the validation that goods or services on the invoice have been received, by linking the invoice to a Goods Receipt document. This is the third component of a three-way match. It is inferred from references on the invoice line item.
Why it matters Matching to a Goods Receipt confirms that the company has received what it is paying for. Tracking this helps analyze the PO-GR-Invoice matching time KPI and streamline validation. Where to get Inferred from the vendor line item in the BSEG table by checking for a populated Goods Receipt document number (BSEG-LFBNR) or by tracing the linked Purchase Order's history (Table EKBE). Capture Check for GR reference in BSEG.LFBNR or via PO history in EKBE. Event type inferred
	Invoice Parked	Represents an invoice that has been entered into SAP but is not yet posted to the general ledger. This is an explicit action allowing for later completion or approval. The document status field in the header table indicates if an invoice is parked.
Why it matters Parking indicates a deliberate pause in the process, often for review or missing information. Tracking this helps identify reasons for delays before an invoice is officially posted. Where to get Identified from the document header table BKPF where the Document Status (BKPF-BSTAT) is 'V' (Parked). The event time is the document creation time (BKPF-CPUDT, BKPF-CPUTM). Capture Filter for documents where BKPF.BSTAT = 'V'. Event type explicit
	Invoice Routed For Approval	The invoice has been formally submitted into an approval workflow. This activity often relies on an external workflow system or a specific status change in SAP. This is often the start of the approval sub-process.
Why it matters This marks the beginning of the approval cycle. Measuring the time from this event to 'Invoice Approved' is crucial for the Invoice Approval Cycle Time KPI and identifying approver-related bottlenecks. Where to get If SAP Business Workflow is used, this event can be extracted from workflow logs (e.g., SWWLOG). If not, this is a conceptual step often inferred from a payment block being set for approval reasons. Capture Extract from workflow logs or infer from setting of a specific payment block. Event type explicit
	Payment Block Removed	A previously set payment block has been removed from the invoice, making it eligible for payment. This often signifies that a discrepancy has been resolved or approval has been granted. The event is captured from change document tables.
Why it matters This activity signifies the resolution of an exception or the completion of an approval. The time spent with the block active represents rework or waiting time, a key area for process improvement. Where to get This event is captured by tracking changes to the Payment Block Key field (BSEG-ZLSPR). Change logs in tables CDHDR and CDPOS record when this field is cleared. Capture Track update entries in CDHDR/CDPOS where field BSEG-ZLSPR is changed to blank. Event type explicit
	Payment Block Set	An invoice is actively blocked from payment, usually due to a discrepancy, pending approval, or other issue. This is an explicit status set on the invoice line item. The event can be captured from change document tables.
Why it matters This activity pinpoints the start of an exception or approval period. Analyzing the frequency and duration of payment blocks is key to identifying and resolving process bottlenecks and disputes. Where to get The event is captured by tracking changes to the Payment Block Key field (BSEG-ZLSPR). Change logs in tables CDHDR and CDPOS record when this field is populated. Capture Track creation of entries in CDHDR/CDPOS for field BSEG-ZLSPR. Event type explicit
	Purchase Order Matched	This activity signifies that the invoice line item has been successfully linked to a Purchase Order. This is a critical validation step in a three-way matching process. It is inferred by the presence of a PO number in the invoice line item details.
Why it matters Delays in PO matching can be a significant bottleneck. Analyzing this activity helps measure the efficiency of the matching process and identify invoices that deviate from the standard PO-based workflow. Where to get Inferred from the vendor line item in the BSEG table. If the Purchase Order Number field (BSEG-EBELN) is populated, the match is considered to have occurred at the time of document creation. Capture Check for a non-null value in BSEG.EBELN for the invoice. Event type inferred

Recommended Optional

Extraction Guides

How to get your data from SAP ECC

Steps

Scope and Design: Before coding, identify the specific SAP Company Codes (BUKRS) and Document Types (BLART) relevant to your Accounts Payable process. Common FI invoice document types are 'KR' (Vendor Invoice) and 'RE' (Invoice Gross). This will be used to filter the data. Confirm with business stakeholders that all 13 required activities are relevant to the process.
Create ABAP Program: Using transaction code SE38 or SE80, create a new executable ABAP program, for example, Z_PM_AP_EXTRACTION. Provide a descriptive title.
Define Selection Screen: In the program, define a selection screen to allow users to specify parameters for the extraction. This must include a date range for the Invoice Posting Date (P_BUDAT), Company Code (P_BUKRS), and Document Type (P_BLART). This makes the tool flexible for different analyses.
Declare Data Structures: Define an internal table structure that matches the final event log format. This structure should include fields for CaseID (Invoice Number), Activity, EventTime, and all other required attributes like VendorName, CompanyCode, etc.
Select Base Invoice Data: Write the core data selection logic. The program will first select invoice headers from BKPF and line items from BSEG based on the user's selection screen parameters. It is efficient to join these with the vendor master table LFA1 to get the VendorName in the initial query.
Generate 'As-Is' Events: Loop through the selected base invoice data. For each invoice, generate events that can be directly determined from the BKPF and BSEG tables. This includes Invoice Document Created, Invoice Parked, Invoice Posted, Purchase Order Matched, Goods Receipt Matched, and Invoice Cleared By Payment. Append each generated event as a new row to your final event log internal table.
Generate Change Log Events: To capture changes like payment blocks, select data from the change document tables CDHDR (header) and CDPOS (item). Search for changes to the ZLSPR (Payment Block Key) field in the BSEG table. Loop through these change documents to create Payment Block Set and Payment Block Removed events with the precise timestamp from CDHDR.
Generate Payment Run Events: Query the payment proposal tables REGUH (header) and REGUP (item) to identify when invoices were included in a payment proposal. This will generate the Payment Proposal Created activity.
Generate Calculated & Inferred Events: Implement logic for events that are not direct system entries. For Due Date Passed Without Payment, compare the invoice due date (BSEG-NETDT) with the clearing date or current date. For Invoice Approved, you may need to infer this from the removal of a specific 'approval required' payment block.
Consolidate and Format Data: Ensure all timestamps are converted to a consistent format (e.g., YYYY-MM-DD HH:MM:SS). Combine all generated events from the steps above into the single final internal table.
Create Output File: Use the cl_gui_frontend_services=>gui_download method or write the file to the application server. The output should be a flat file (e.g., CSV) with a header row that matches the ProcessMind data model requirements. The file is now ready for upload.

Configuration

Selection Parameters: The program should have a selection screen with the following mandatory and optional fields:
- S_BUDAT: Posting Date Range (Required). Defines the time window for the extraction.
- S_BUKRS: Company Code (Required). Focuses the extraction on specific legal entities.
- S_BLART: Document Type (Optional). Allows filtering for specific invoice types like 'KR' or 'RE'.
Date Range Recommendation: For the initial extraction, it's recommended to select a recent period of 3 to 6 months to ensure manageable data volume and faster execution. Full historical loads should be run in the background.
Performance Considerations: The selection from change log tables (CDHDR/CDPOS) can be slow. Ensure the query uses primary keys and indexed fields where possible. For very large datasets, consider running the program as a background job (Transaction SM36) to avoid dialog process timeouts.
Prerequisites & Authorizations:
- The user executing the program needs authorization to access tables BKPF, BSEG, LFA1, CDHDR, CDPOS, REGUH, and REGUP.
- Execution permissions for transaction SE38 are required to run the program.
- For the Payment Block Set/Removed activities to be captured, change document logging must be active for the ZLSPR field of the BSEG table. This is a system configuration setting.

a Sample Query abap

*&---------------------------------------------------------------------*
*& Report Z_PM_AP_EXTRACTION
*&---------------------------------------------------------------------*
*& This program extracts Accounts Payable invoice data for process mining.
*& It creates an event log based on key business activities.
*&---------------------------------------------------------------------*
REPORT z_pm_ap_extraction.

*&---------------------------------------------------------------------*
*& Global Data Declarations
*&---------------------------------------------------------------------*
TABLES: bkpf, bseg, lfa1.

TYPES:
  BEGIN OF ty_event_log,
    invoicenumber       TYPE belnr_d,
    activity            TYPE string,
    eventtime           TYPE string,
    processoruser       TYPE uname,
    vendorname          TYPE name1_gp,
    companycode         TYPE bukrs,
    invoicegrossamount  TYPE wrbtr,
    invoiceduedate      TYPE c, "char20
    paymentterms        TYPE char256,
    purchaseordernumber TYPE ebeln,
    paymentblockreason  TYPE char256,
    approver            TYPE uname,
  END OF ty_event_log.

DATA: gt_event_log TYPE TABLE OF ty_event_log.

TYPES:
  BEGIN OF ty_invoice_data,
    bukrs TYPE bkpf-bukrs,
    belnr TYPE bkpf-belnr,
    gjahr TYPE bkpf-gjahr,
    blart TYPE bkpf-blart,
    budat TYPE bkpf-budat,
    cpudt TYPE bkpf-cpudt,
    cputm TYPE bkpf-cputm,
    usnam TYPE bkpf-usnam,
    bstat TYPE bkpf-bstat,
    stblg TYPE bkpf-stblg,
    xblnr TYPE bkpf-xblnr,
    lifnr TYPE bseg-lifnr,
    buzei TYPE bseg-buzei,
    wrbtr TYPE bseg-wrbtr,
    zterm TYPE bseg-zterm,
    zlspr TYPE bseg-zlspr,
    netdt TYPE bseg-netdt,
    ebeln TYPE bseg-ebeln,
    lfbnr TYPE bseg-lfbnr,
    augbl TYPE bseg-augbl,
    augdt TYPE bseg-augdt,
    name1 TYPE lfa1-name1,
  END OF ty_invoice_data.

DATA: gt_invoice_data TYPE TABLE OF ty_invoice_data.

*&---------------------------------------------------------------------*
*& Selection Screen
*&---------------------------------------------------------------------*
SELECTION-SCREEN BEGIN OF BLOCK b1 WITH FRAME TITLE TEXT-001.
  SELECT-OPTIONS: s_budat FOR bkpf-budat OBLIGATORY,  " Posting Date
                    s_bukrs FOR bkpf-bukrs OBLIGATORY,  " Company Code
                    s_blart FOR bkpf-blart.             " Document Type
SELECTION-SCREEN END OF BLOCK b1.

PARAMETERS: p_file TYPE rlgrap-filename OBLIGATORY DEFAULT 'C:\temp\ap_event_log.csv'.

*&---------------------------------------------------------------------*
*& Main Program Logic
*&---------------------------------------------------------------------*
START-OF-SELECTION.

  " 1. Select base invoice data
  SELECT
    h~bukrs, h~belnr, h~gjahr, h~blart, h~budat, h~cpudt, h~cputm, h~usnam,
    h~bstat, h~stblg, h~xblnr, i~lifnr, i~buzei, i~wrbtr, i~zterm, i~zlspr,
    i~netdt, i~ebeln, i~lfbnr, i~augbl, i~augdt, v~name1
    INTO TABLE @gt_invoice_data
    FROM bkpf AS h
    INNER JOIN bseg AS i ON  h~bukrs = i~bukrs
                         AND h~belnr = i~belnr
                         AND h~gjahr = i~gjahr
    INNER JOIN lfa1 AS v ON i~lifnr = v~lifnr
    WHERE h~budat IN @s_budat
      AND h~bukrs IN @s_bukrs
      AND h~blart IN @s_blart
      AND i~koart = 'K'. " Vendor line items only

  CHECK gt_invoice_data IS NOT INITIAL.

  " 2. Process each invoice to generate events
  LOOP AT gt_invoice_data ASSIGNING FIELD-SYMBOL(<fs_invoice>).
    " Generate events for each invoice document/line item
    PERFORM generate_events USING <fs_invoice>.
  ENDLOOP.

  " 3. Generate events from change documents (payment blocks)
  PERFORM generate_change_log_events.

  " 4. Generate events from payment proposal run
  PERFORM generate_payment_proposal_events.

  " 5. Download the final event log
  PERFORM download_event_log.


*&---------------------------------------------------------------------*
*&      Form  GENERATE_EVENTS
*&---------------------------------------------------------------------*
FORM generate_events USING is_invoice TYPE ty_invoice_data.
  DATA: ls_event_log TYPE ty_event_log,
        lv_timestamp TYPE string.

  " Common attributes for all events of this invoice
  ls_event_log-invoicenumber      = is_invoice-belnr.
  ls_event_log-companycode        = is_invoice-bukrs.
  ls_event_log-vendorname         = is_invoice-name1.
  ls_event_log-invoicegrossamount = is_invoice-wrbtr.
  ls_event_log-paymentterms       = is_invoice-zterm.
  ls_event_log-purchaseordernumber= is_invoice-ebeln.

  " Format Due Date
  WRITE is_invoice-netdt TO ls_event_log-invoiceduedate DD/MM/YYYY.

  " Activity: Invoice Document Created
  CONCATENATE is_invoice-cpudt is_invoice-cputm INTO lv_timestamp.
  ls_event_log-activity     = 'Invoice Document Created'.
  ls_event_log-eventtime    = lv_timestamp.
  ls_event_log-processoruser= is_invoice-usnam.
  APPEND ls_event_log TO gt_event_log.

  " Activity: Invoice Parked
  IF is_invoice-bstat = 'V'.
    ls_event_log-activity     = 'Invoice Parked'.
    ls_event_log-eventtime    = lv_timestamp. " Parked at time of creation
    ls_event_log-processoruser= is_invoice-usnam.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

  " Activity: Invoice Posted
  IF is_invoice-bstat = space.
    CONCATENATE is_invoice-budat '000000' INTO lv_timestamp.
    ls_event_log-activity     = 'Invoice Posted'.
    ls_event_log-eventtime    = lv_timestamp.
    ls_event_log-processoruser= is_invoice-usnam.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

  " Activity: Purchase Order Matched
  IF is_invoice-ebeln IS NOT INITIAL.
    CONCATENATE is_invoice-cpudt is_invoice-cputm INTO lv_timestamp.
    ls_event_log-activity     = 'Purchase Order Matched'.
    ls_event_log-eventtime    = lv_timestamp.
    ls_event_log-processoruser= is_invoice-usnam.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

  " Activity: Goods Receipt Matched
  IF is_invoice-lfbnr IS NOT INITIAL.
    CONCATENATE is_invoice-cpudt is_invoice-cputm INTO lv_timestamp.
    ls_event_log-activity     = 'Goods Receipt Matched'.
    ls_event_log-eventtime    = lv_timestamp.
    ls_event_log-processoruser= is_invoice-usnam.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

  " Activity: Invoice Cleared By Payment
  IF is_invoice-augbl IS NOT INITIAL.
    CONCATENATE is_invoice-augdt '000000' INTO lv_timestamp.
    ls_event_log-activity     = 'Invoice Cleared By Payment'.
    ls_event_log-eventtime    = lv_timestamp.
    " Processor user for clearing is not in this structure, would require another SELECT
    ls_event_log-processoruser = ''.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

  " Activity: Invoice Reversed
  IF is_invoice-stblg IS NOT INITIAL.
    SELECT SINGLE budat INTO @DATA(lv_rev_date) FROM bkpf
      WHERE belnr = @is_invoice-stblg AND gjahr = @is_invoice-gjahr.
    IF sy-subrc = 0.
      CONCATENATE lv_rev_date '000000' INTO lv_timestamp.
      ls_event_log-activity     = 'Invoice Reversed'.
      ls_event_log-eventtime    = lv_timestamp.
      ls_event_log-processoruser= sy-uname.
      APPEND ls_event_log TO gt_event_log.
    ENDIF.
  ENDIF.

  " Activity: Due Date Passed Without Payment
  IF is_invoice-netdt < sy-datum AND is_invoice-augbl IS INITIAL.
    CONCATENATE is_invoice-netdt '000000' INTO lv_timestamp.
    ls_event_log-activity      = 'Due Date Passed Without Payment'.
    ls_event_log-eventtime     = lv_timestamp.
    ls_event_log-processoruser = 'SYSTEM'.
    APPEND ls_event_log TO gt_event_log.
  ENDIF.

ENDFORM.

*&---------------------------------------------------------------------*
*&      Form  GENERATE_CHANGE_LOG_EVENTS
*&---------------------------------------------------------------------*
FORM generate_change_log_events.
  TYPES: BEGIN OF ty_cdpos,
           objectid TYPE cdpos-objectid,
           changenr TYPE cdpos-changenr,
           fname    TYPE cdpos-fname,
           value_new TYPE cdpos-value_new,
           value_old TYPE cdpos-value_old,
         END OF ty_cdpos.

  DATA: lt_cdpos TYPE TABLE OF ty_cdpos,
        lt_cdhdr TYPE TABLE OF cdhdr.

  DATA: ls_event_log TYPE ty_event_log.

  DATA(lt_invoice_range) = VALUE range_belnr_d( FOR wa IN gt_invoice_data ( sign = 'I' option = 'EQ' low = wa-belnr ) ).
  CHECK lt_invoice_range IS NOT INITIAL.

  SELECT objectclas, objectid, changenr, username, udate, utime
    FROM cdhdr
    INTO TABLE @lt_cdhdr
    FOR ALL ENTRIES IN @gt_invoice_data
    WHERE objectclas = 'BELEG'
      AND objectid   = @gt_invoice_data-objectid.
  CHECK sy-subrc = 0.

  SELECT objectid, changenr, fname, value_new, value_old
    FROM cdpos
    INTO TABLE @lt_cdpos
    FOR ALL ENTRIES IN @lt_cdhdr
    WHERE changenr = @lt_cdhdr-changenr
      AND objectid = @lt_cdhdr-objectid
      AND tabname  = 'BSEG'
      AND fname    = 'ZLSPR'.
  CHECK sy-subrc = 0.

  LOOP AT lt_cdpos ASSIGNING FIELD-SYMBOL(<fs_cdpos>).
    READ TABLE lt_cdhdr ASSIGNING FIELD-SYMBOL(<fs_cdhdr>) WITH KEY changenr = <fs_cdpos>-changenr.
    IF sy-subrc <> 0. CONTINUE. ENDIF.

    " Find corresponding invoice data
    DATA(lv_belnr) = <fs_cdhdr>-objectid+10(10).
    READ TABLE gt_invoice_data ASSIGNING FIELD-SYMBOL(<fs_invoice>) WITH KEY belnr = lv_belnr.
    IF sy-subrc <> 0. CONTINUE. ENDIF.

    " Populate common event data
    ls_event_log-invoicenumber       = <fs_invoice>-belnr.
    ls_event_log-companycode         = <fs_invoice>-bukrs.
    ls_event_log-vendorname          = <fs_invoice>-name1.
    ls_event_log-invoicegrossamount  = <fs_invoice>-wrbtr.
    ls_event_log-purchaseordernumber = <fs_invoice>-ebeln.
    ls_event_log-processoruser       = <fs_cdhdr>-username.

    CONCATENATE <fs_cdhdr>-udate <fs_cdhdr>-utime INTO ls_event_log-eventtime.

    " Activity: Payment Block Set
    IF <fs_cdpos>-value_new IS NOT INITIAL.
      ls_event_log-activity           = 'Payment Block Set'.
      ls_event_log-paymentblockreason = <fs_cdpos>-value_new.
      APPEND ls_event_log TO gt_event_log.
    ENDIF.

    " Activity: Payment Block Removed
    IF <fs_cdpos>-value_new IS INITIAL AND <fs_cdpos>-value_old IS NOT INITIAL.
      ls_event_log-activity           = 'Payment Block Removed'.
      ls_event_log-paymentblockreason = <fs_cdpos>-value_old.
      APPEND ls_event_log TO gt_event_log.

      " INFERRED Activity: Invoice Approved
      " Assumption: Removing a specific block (e.g., 'A' for Approval) means approval.
      IF <fs_cdpos>-value_old = '[Your Approval Block Reason]'. " E.g., 'A'
        ls_event_log-activity           = 'Invoice Approved'.
        ls_event_log-approver           = <fs_cdhdr>-username.
        APPEND ls_event_log TO gt_event_log.
      ENDIF.
    ENDIF.

    " INFERRED Activity: Invoice Routed For Approval
    " Assumption: Setting a specific block (e.g., 'A' for Approval) means routed for approval.
    IF <fs_cdpos>-value_new = '[Your Approval Block Reason]'. " E.g., 'A'
      ls_event_log-activity           = 'Invoice Routed For Approval'.
      ls_event_log-approver           = ''.
      APPEND ls_event_log TO gt_event_log.
    ENDIF.

  ENDLOOP.
ENDFORM.

*&---------------------------------------------------------------------*
*&      Form  GENERATE_PAYMENT_PROPOSAL_EVENTS
*&---------------------------------------------------------------------*
FORM generate_payment_proposal_events.
  DATA: lt_regup TYPE TABLE OF regup,
        ls_reguh TYPE reguh.
  DATA: ls_event_log TYPE ty_event_log.

  SELECT * FROM regup INTO TABLE @lt_regup
    FOR ALL ENTRIES IN @gt_invoice_data
    WHERE bukrs = @gt_invoice_data-bukrs
      AND belnr = @gt_invoice_data-belnr
      AND gjahr = @gt_invoice_data-gjahr.
  CHECK sy-subrc = 0.

  LOOP AT lt_regup ASSIGNING FIELD-SYMBOL(<fs_regup>).
    READ TABLE gt_invoice_data ASSIGNING FIELD-SYMBOL(<fs_invoice>) WITH KEY belnr = <fs_regup>-belnr.
    IF sy-subrc <> 0. CONTINUE. ENDIF.

    SELECT SINGLE * FROM reguh INTO @ls_reguh
      WHERE rundat = @<fs_regup>-rundat AND runid = @<fs_regup>-runid.
    IF sy-subrc <> 0. CONTINUE. ENDIF.

    ls_event_log-invoicenumber      = <fs_invoice>-belnr.
    ls_event_log-companycode        = <fs_invoice>-bukrs.
    ls_event_log-vendorname         = <fs_invoice>-name1.
    ls_event_log-invoicegrossamount = <fs_invoice>-wrbtr.
    ls_event_log-processoruser      = ls_reguh-usnam.
    ls_event_log-activity           = 'Payment Proposal Created'.

    CONCATENATE ls_reguh-rundat '000000' INTO ls_event_log-eventtime.
    APPEND ls_event_log TO gt_event_log.
  ENDLOOP.
ENDFORM.

*&---------------------------------------------------------------------*
*&      Form  DOWNLOAD_EVENT_LOG
*&---------------------------------------------------------------------*
FORM download_event_log.
  DATA: lt_final_output TYPE TABLE OF string,
        l_header        TYPE string.

  SORT gt_event_log BY invoicenumber eventtime.

  " Create Header
  l_header = `"InvoiceNumber","Activity","EventTime","ProcessorUser","VendorName","CompanyCode","InvoiceGrossAmount","InvoiceDueDate","PaymentTerms","PurchaseOrderNumber","PaymentBlockReason","Approver"`.
  APPEND l_header TO lt_final_output.

  " Create Data Rows
  LOOP AT gt_event_log ASSIGNING FIELD-SYMBOL(<fs_log>).
    DATA(l_line) = |"{ <fs_log>-invoicenumber }","{
                     <fs_log>-activity }","{
                     <fs_log>-eventtime }","{
                     <fs_log>-processoruser }","{
                     <fs_log>-vendorname }","{
                     <fs_log>-companycode }","{
                     <fs_log>-invoicegrossamount }","{
                     <fs_log>-invoiceduedate }","{
                     <fs_log>-paymentterms }","{
                     <fs_log>-purchaseordernumber }","{
                     <fs_log>-paymentblockreason }","{
                     <fs_log>-approver }"|.
    APPEND l_line TO lt_final_output.
  ENDLOOP.

  " Download file to presentation server
  cl_gui_frontend_services=>gui_download(
    EXPORTING
      filename = p_file
      filetype = 'ASC'
    CHANGING
      data_tab = lt_final_output
    EXCEPTIONS
      OTHERS   = 4 ).

  IF sy-subrc <> 0.
    MESSAGE 'File download failed.' TYPE 'E'.
  ELSE.
    MESSAGE |File '{ p_file }' downloaded successfully.| TYPE 'I'.
  ENDIF.
ENDFORM.

Steps

Prerequisites & Access: Ensure you have a database user with read permissions on the required SAP tables (e.g., BKPF, BSEG, LFA1, CDHDR, CDPOS, REGUH, REGUP). This method requires direct database access, which may need approval from your IT security and SAP Basis teams.
Identify System Details: Confirm the specific database type your SAP ECC system runs on (e.g., SAP HANA, Oracle, MS SQL Server). The provided SQL query uses syntax common on SAP HANA and may require minor adjustments for other databases, particularly for timestamp creation.
Customize the Query: Open the provided SQL query in a database client (like DBeaver, SAP HANA Studio, or SQL Server Management Studio). Modify the placeholder values at the top of the query in the BaseInvoices CTE:
- '{StartDate}': Set the first date of the extraction period (e.g., '2023-01-01').
- '{EndDate}': Set the last date of the extraction period (e.g., '2023-06-30').
- '{CompanyCodes}': Replace with a comma-separated list of the company codes you want to analyze (e.g., '1000', '2000').
- '{DocTypes}': Confirm the document types for vendor invoices in your system. 'KR' and 'RE' are common defaults.
Execute the Query: Run the customized SQL query against the SAP database. The execution time will depend on the date range, number of company codes, and overall system size.
Review Query Output: Once the query completes, inspect the first few hundred rows of the output. Check that all columns (InvoiceNumber, Activity, EventTime, etc.) are present and populated as expected.
Handle Potential Errors: If you encounter syntax errors, adjust the date/time functions to match your specific database. For example, TO_TIMESTAMP (HANA/Oracle) might need to be changed to a CAST or CONVERT function (SQL Server).
Export the Data: Export the complete result set from your SQL client to a CSV (Comma-Separated Values) file. Ensure the file encoding is set to UTF-8 to prevent issues with special characters.
Prepare for Upload: Name the columns in the CSV file exactly as specified in the query aliases (InvoiceNumber, Activity, EventTime, ProcessorUser, etc.). This ensures seamless mapping during the upload process.
Upload to Process Mining Tool: Upload the final CSV file to your process mining application. Map the InvoiceNumber column to 'Case ID', Activity to 'Activity', and EventTime to 'Timestamp' to begin your analysis.

Configuration

Database Connection: A direct read-only connection to the underlying SAP ECC database is required. You will need the server address, database name, port, username, and password.
Date Range: It is recommended to start with a limited date range (e.g., 3-6 months) to ensure performance and validate the results before running a larger extraction. The date filter is applied on the document creation date (BKPF.CPUDT).
Company Codes: The query must be filtered by one or more CompanyCode (BUKRS) values. Extracting for all company codes at once on a large system is not recommended.
Document Types: The extraction is filtered by invoice document types (BLART). Common types for vendor invoices are KR (Vendor Invoice) and RE (Invoice Receipt). Consult with your finance team to confirm the relevant types for your organization.
Table Authorizations: The database user needs SELECT permissions on the following tables: BKPF, BSEG, LFA1, CDHDR, CDPOS, REGUH, REGUP.
Timestamp Conversion: The query uses TO_TIMESTAMP(CONCAT(date, time), 'YYYYMMDDHH24MISS'). This is compatible with SAP HANA and Oracle. For SQL Server, you might use CAST(CONCAT(date, ' ', time) AS DATETIME2). This may require adjustment based on your target database.

a Sample Query sql

WITH BaseInvoices AS (
  SELECT
    BKPF.MANDT,
    BKPF.BUKRS,
    BKPF.BELNR,
    BKPF.GJAHR,
    CONCAT(CONCAT(CONCAT(BKPF.BUKRS, '-'), BKPF.BELNR), BKPF.GJAHR) AS InvoiceNumber,
    BKPF.CPUDT AS CreationDate,
    BKPF.CPUTM AS CreationTime,
    BKPF.USNAM AS CreatorUser,
    BKPF.BSTAT AS DocStatus,
    BKPF.STBLG AS ReversalDoc,
    BKPF.STGRD AS ReversalDate
  FROM BKPF
  WHERE
    BKPF.BUKRS IN ('{CompanyCodes}') -- E.g., '1000', '2000'
    AND BKPF.BLART IN ('{DocTypes}') -- E.g., 'KR', 'RE'
    AND BKPF.CPUDT BETWEEN '{StartDate}' AND '{EndDate}' -- E.g., '20230101' AND '20231231'
),
InvoiceVendorLines AS (
  SELECT
    BSEG.MANDT, BSEG.BUKRS, BSEG.BELNR, BSEG.GJAHR,
    MAX(BSEG.LIFNR) AS VendorNumber,
    MAX(BSEG.ZFBDT) AS DueDate,
    MAX(BSEG.ZTERM) AS PaymentTerms,
    MAX(BSEG.ZLSPR) AS PaymentBlockReason,
    SUM(CASE WHEN BSEG.SHKZG = 'S' THEN BSEG.WRBTR ELSE -BSEG.WRBTR END) AS InvoiceGrossAmount,
    MAX(BSEG.EBELN) AS PurchaseOrderNumber,
    MAX(BSEG.AUGDT) AS ClearingDate,
    MAX(AUGBL) AS ClearingDoc
  FROM BSEG
  INNER JOIN BaseInvoices ON BSEG.MANDT = BaseInvoices.MANDT
    AND BSEG.BUKRS = BaseInvoices.BUKRS
    AND BSEG.BELNR = BaseInvoices.BELNR
    AND BSEG.GJAHR = BaseInvoices.GJAHR
  WHERE BSEG.KOART = 'K' -- Filter for Vendor line items
  GROUP BY BSEG.MANDT, BSEG.BUKRS, BSEG.BELNR, BSEG.GJAHR
)
-- 1. Invoice Document Created
SELECT
  bi.InvoiceNumber AS "InvoiceNumber",
  'Invoice Document Created' AS "Activity",
  TO_TIMESTAMP(CONCAT(bi.CreationDate, bi.CreationTime), 'YYYYMMDDHH24MISS') AS "EventTime",
  bi.CreatorUser AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR

UNION ALL

-- 2. Invoice Parked
SELECT
  bi.InvoiceNumber,
  'Invoice Parked' AS "Activity",
  TO_TIMESTAMP(CONCAT(bi.CreationDate, bi.CreationTime), 'YYYYMMDDHH24MISS') AS "EventTime",
  bi.CreatorUser AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE bi.DocStatus = 'V'

UNION ALL

-- 3. Purchase Order Matched & 4. Goods Receipt Matched (Inferred at creation)
SELECT
  bi.InvoiceNumber,
  CASE WHEN ivl.PurchaseOrderNumber IS NOT NULL THEN 'Purchase Order Matched' ELSE 'Goods Receipt Matched' END AS "Activity",
  TO_TIMESTAMP(CONCAT(bi.CreationDate, bi.CreationTime), 'YYYYMMDDHH24MISS') AS "EventTime",
  bi.CreatorUser AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE ivl.PurchaseOrderNumber IS NOT NULL -- Simplified logic: If PO exists, we assume match for both.

UNION ALL

-- 5. Payment Block Set & 6. Invoice Routed For Approval (Proxy) & 8. Payment Block Removed
SELECT
  bi.InvoiceNumber,
  CASE 
    WHEN pos.VALUE_OLD = ' ' AND pos.VALUE_NEW != ' ' AND pos.VALUE_NEW = 'A' THEN 'Invoice Routed For Approval'
    WHEN pos.VALUE_OLD = ' ' AND pos.VALUE_NEW != ' ' THEN 'Payment Block Set'
    ELSE 'Payment Block Removed' 
  END AS "Activity",
  TO_TIMESTAMP(CONCAT(hdr.UDATE, hdr.UTIME), 'YYYYMMDDHH24MISS') AS "EventTime",
  hdr.USERNAME AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  pos.VALUE_NEW AS "PaymentBlockReason",
  NULL AS "Approver"
FROM CDHDR hdr
JOIN CDPOS pos ON hdr.MANDANT = pos.MANDANT AND hdr.OBJECTCLAS = pos.OBJECTCLAS AND hdr.OBJECTID = pos.OBJECTID AND hdr.CHANGENR = pos.CHANGENR
JOIN BaseInvoices bi ON hdr.MANDANT = bi.MANDT AND hdr.OBJECTID = CONCAT(bi.BUKRS, bi.BELNR, bi.GJAHR)
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE hdr.OBJECTCLAS = 'BELEG' AND pos.TABNAME = 'BSEG' AND pos.FNAME = 'ZLSPR' AND pos.VALUE_NEW != pos.VALUE_OLD

UNION ALL

-- 7. Invoice Approved (Proxy by removal of 'A' block)
SELECT
  bi.InvoiceNumber,
  'Invoice Approved' AS "Activity",
  TO_TIMESTAMP(CONCAT(hdr.UDATE, hdr.UTIME), 'YYYYMMDDHH24MISS') AS "EventTime",
  hdr.USERNAME AS "ProcessorUser", -- This user is the approver
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  pos.VALUE_NEW AS "PaymentBlockReason",
  hdr.USERNAME AS "Approver"
FROM CDHDR hdr
JOIN CDPOS pos ON hdr.MANDANT = pos.MANDANT AND hdr.OBJECTCLAS = pos.OBJECTCLAS AND hdr.OBJECTID = pos.OBJECTID AND hdr.CHANGENR = pos.CHANGENR
JOIN BaseInvoices bi ON hdr.MANDANT = bi.MANDT AND hdr.OBJECTID = CONCAT(bi.BUKRS, bi.BELNR, bi.GJAHR)
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE hdr.OBJECTCLAS = 'BELEG' AND pos.TABNAME = 'BSEG' AND pos.FNAME = 'ZLSPR' AND pos.VALUE_OLD = 'A' AND pos.VALUE_NEW = ' '

UNION ALL

-- 9. Invoice Posted
SELECT
  bi.InvoiceNumber,
  'Invoice Posted' AS "Activity",
  CASE -- If posted from parked, use change date. If posted directly, use creation date.
    WHEN chg.EventTime IS NOT NULL THEN chg.EventTime
    ELSE TO_TIMESTAMP(CONCAT(bi.CreationDate, bi.CreationTime), 'YYYYMMDDHH24MISS')
  END AS "EventTime",
  CASE
    WHEN chg.USERNAME IS NOT NULL THEN chg.USERNAME
    ELSE bi.CreatorUser
  END AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
LEFT JOIN (
    SELECT hdr.MANDANT, hdr.OBJECTID, hdr.USERNAME, TO_TIMESTAMP(CONCAT(hdr.UDATE, hdr.UTIME), 'YYYYMMDDHH24MISS') AS EventTime
    FROM CDHDR hdr JOIN CDPOS pos ON hdr.CHANGENR = pos.CHANGENR AND hdr.OBJECTID = pos.OBJECTID
    WHERE hdr.OBJECTCLAS = 'BELEG' AND pos.TABNAME = 'BKPF' AND pos.FNAME = 'BSTAT' AND pos.VALUE_OLD = 'V' AND pos.VALUE_NEW = ' '
) chg ON bi.MANDT = chg.MANDANT AND CONCAT(bi.BUKRS, bi.BELNR, bi.GJAHR) = chg.OBJECTID
WHERE bi.DocStatus != 'V' -- Only include documents that are currently posted

UNION ALL

-- 10. Due Date Passed Without Payment
SELECT
  bi.InvoiceNumber,
  'Due Date Passed Without Payment' AS "Activity",
  TO_TIMESTAMP(ivl.DueDate, 'YYYYMMDD') AS "EventTime",
  'System' AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE ivl.ClearingDoc IS NULL AND ivl.DueDate < CURRENT_DATE

UNION ALL

-- 11. Payment Proposal Created
SELECT DISTINCT
  bi.InvoiceNumber,
  'Payment Proposal Created' AS "Activity",
  TO_TIMESTAMP(CONCAT(reguh.LAUFD, '000000'), 'YYYYMMDDHH24MISS') AS "EventTime", -- Time is not available in REGUH
  reguh.USNAM AS "ProcessorUser",
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
JOIN REGUP ON ivl.MANDT = REGUP.MANDT AND ivl.BUKRS = REGUP.BUKRS AND ivl.BELNR = REGUP.BELNR AND ivl.GJAHR = REGUP.GJAHR
JOIN REGUH ON REGUP.MANDT = REGUH.MANDT AND REGUP.LAUFD = REGUH.LAUFD AND REGUP.LAUFI = REGUH.LAUFI AND REGUP.XVORL = REGUH.XVORL AND REGUP.ZBUKR = REGUH.ZBUKR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR

UNION ALL

-- 12. Invoice Cleared By Payment
SELECT
  bi.InvoiceNumber,
  'Invoice Cleared By Payment' AS "Activity",
  TO_TIMESTAMP(ivl.ClearingDate, 'YYYYMMDD') AS "EventTime",
  NULL AS "ProcessorUser", -- Clearing user is not on the vendor line
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  ivl.PaymentBlockReason AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE ivl.ClearingDoc IS NOT NULL

UNION ALL

-- 13. Invoice Reversed
SELECT
  bi.InvoiceNumber,
  'Invoice Reversed' AS "Activity",
  TO_TIMESTAMP(bi.ReversalDate, 'YYYYMMDD') AS "EventTime",
  NULL AS "ProcessorUser", -- Reversal user not in BKPF, would require another join
  vend.Name1 AS "VendorName",
  bi.BUKRS AS "CompanyCode",
  ivl.InvoiceGrossAmount AS "InvoiceGrossAmount",
  ivl.DueDate AS "InvoiceDueDate",
  ivl.PaymentTerms AS "PaymentTerms",
  ivl.PurchaseOrderNumber AS "PurchaseOrderNumber",
  NULL AS "PaymentBlockReason",
  NULL AS "Approver"
FROM BaseInvoices bi
JOIN InvoiceVendorLines ivl ON bi.MANDT = ivl.MANDT AND bi.BUKRS = ivl.BUKRS AND bi.BELNR = ivl.BELNR AND bi.GJAHR = ivl.GJAHR
LEFT JOIN LFA1 vend ON ivl.MANDT = vend.MANDT AND ivl.VendorNumber = vend.LIFNR
WHERE bi.ReversalDoc IS NOT NULL;

Steps

Prerequisites Installation: Ensure your Python environment has the necessary libraries installed. This includes pandas for data manipulation and pyrfc for SAP RFC communication. Additionally, the SAP NetWeaver RFC SDK must be downloaded from the SAP support portal and its lib directory must be accessible in your system's path.
SAP Connection Setup: In the Python script, configure the SAP connection dictionary with your system's specific details: Application Server Host (ashost), System Number (sysnr), Client (client), User (user), and Password (passwd). Ensure the specified SAP user has the required authorizations, primarily S_RFC and S_TABU_DIS for RFC_READ_TABLE access to the required tables.
Define Extraction Parameters: Set the key parameters for the data extraction at the top of the script. This includes the date_range (start and end dates for invoice entry), and a list of company_codes to focus the extraction on relevant business units.
Data Extraction from SAP Tables: Execute the Python script. It will connect to the SAP system via the RFC protocol and call the RFC_READ_TABLE function multiple times to extract raw data from core Accounts Payable tables. This includes BKPF (headers), BSEG (line items), RSEG (invoice receipt details), LFA1 (vendor master), CDHDR/CDPOS (change logs for blocks), and BSAK (cleared items).
In-Memory Data Joining: The script uses the pandas library to perform joins on the extracted dataframes. It links invoice headers to line items, enriches data with vendor names, and connects invoices to their corresponding change document records. This creates a comprehensive, flat dataset for each invoice.
Event Log Transformation: This is the core logic of the script. It iterates through the joined data to create a distinct record for each of the 13 required business activities. For each activity (e.g., 'Invoice Parked', 'Payment Block Set'), it assigns the correct activity name and determines the precise timestamp from the relevant date and time fields in the SAP data.
Handling Calculated Events: The script calculates events that are not directly logged in SAP. For example, the 'Due Date Passed Without Payment' event is generated by comparing the invoice due date (ZFBDT) with the current date for all uncleared invoices.
Attribute Population: For each event record, the script populates a consistent set of attributes. This includes required fields like InvoiceNumber, Activity, and EventTime, as well as recommended attributes like VendorName, InvoiceGrossAmount, and CompanyCode to provide rich context for process analysis.
Final Consolidation: The script collects all individual event dataframes into a single, final event log dataframe. It ensures consistent column naming and data types across all records.
Export to CSV: The final step is to save the consolidated event log dataframe to a CSV file. This file is formatted for direct upload into process mining tools like ProcessMind. The script will output a file named sap_ap_event_log.csv in the same directory where the script is run.

Configuration

SAP Connection Parameters: The script requires a dictionary containing connection details: ashost (hostname or IP), sysnr (system number), client (e.g., '100'), user (SAP username), and passwd (SAP password).
Date Range: Define a start_date and end_date in 'YYYYMMDD' format. This filter is applied to the invoice entry date (BKPF-CPUDT) to limit the scope of the extraction. A range of 3-6 months is recommended for initial analysis to balance data volume and insight.
Company Code (BUKRS): Specify a list of SAP Company Codes to include in the extraction. This is a critical filter to ensure you are analyzing the correct organizational entities (e.g., ['1000', '2000']).
Document Type (BLART): While not explicitly a parameter in this script, you can easily add a filter for Document Type (e.g., 'KR' for vendor invoice, 'RE' for invoice receipt) to the RFC_READ_TABLE calls on BKPF to further refine the dataset.
Performance & Chunking: The script reads full tables based on the filters. For very large datasets (millions of invoices), RFC_READ_TABLE can time out or consume excessive memory. Consider implementing chunking by iterating through the date range month-by-month if you encounter performance issues.
SAP Authorizations: The SAP user must have RFC execution rights and authorization to display data from the following tables: BKPF, BSEG, RSEG, LFA1, CDHDR, CDPOS, BSAK, BSIK, REGUH, REGUP. This is typically granted through authorization object S_TABU_DIS.

a Sample Query python

import pandas as pd
from pyrfc import Connection
from datetime import datetime

class=class="hl-string">"hl-comment"># --- 1. SETTINGS & PARAMETERS ---

class=class="hl-string">"hl-comment"># SAP Connection Details (replace with your system's details)
sap_conn_params = {
    class="hl-string">"user": class="hl-string">"[SAP_USER]",
    class="hl-string">"passwd": class="hl-string">"[SAP_PASSWORD]",
    class="hl-string">"ashost": class="hl-string">"[SAP_HOST]",
    class="hl-string">"sysnr": class="hl-string">"[SYSTEM_NUMBER]",
    class="hl-string">"client": class="hl-string">"[CLIENT]"
}

class=class="hl-string">"hl-comment"># Extraction Parameters
company_codes = [class="hl-string">'[YOUR_COMPANY_CODE_1]', class="hl-string">'[YOUR_COMPANY_CODE_2]']
date_range = {
    class="hl-string">"start_date": class="hl-string">"20230101", class=class="hl-string">"hl-comment"># YYYYMMDD
    class="hl-string">"end_date": class="hl-string">"20231231"    class=class="hl-string">"hl-comment"># YYYYMMDD
}

class=class="hl-string">"hl-comment"># --- 2. HELPER FUNCTION TO READ SAP TABLE ---
def read_sap_table(conn, table_name, fields=[], options=[], row_count=0):
    class="hl-string">"""Reads an SAP table using RFC_READ_TABLE and returns a pandas DataFrame."""
    try:
        result = conn.call(class="hl-string">'RFC_READ_TABLE',
                             QUERY_TABLE=table_name,
                             DELIMITER=class="hl-string">'|',
                             FIELDS=fields,
                             OPTIONS=options,
                             ROWCOUNT=row_count)
        
        data = result[class="hl-string">'DATA']
        if not data:
            return pd.DataFrame(columns=[f[class="hl-string">'FIELDNAME'] for f in result[class="hl-string">'FIELDS']])

        df = pd.DataFrame([row[class="hl-string">'WA'].split(class="hl-string">'|') for row in data])
        df.columns = [f[class="hl-string">'FIELDNAME'] for f in result[class="hl-string">'FIELDS']]
        return df
    except Exception as e:
        print(fclass="hl-string">"Error reading table {table_name}: {e}")
        return pd.DataFrame(columns=[f[class="hl-string">'FIELDNAME'] for f in fields])

class=class="hl-string">"hl-comment"># --- 3. DATA EXTRACTION ---
print(class="hl-string">"Starting SAP data extraction...")

with Connection(**sap_conn_params) as conn:
    class=class="hl-string">"hl-comment"># Define filters
    company_code_filter = class="hl-string">" OR ".join([fclass="hl-string">"BUKRS = '{cc}'" for cc in company_codes])
    date_filter = fclass="hl-string">"CPUDT >= '{date_range['start_date']}' AND CPUDT <= '{date_range['end_date']}'"
    bkpf_filter = [fclass="hl-string">"({company_code_filter}) AND ({date_filter})"]

    class=class="hl-string">"hl-comment"># Extract main tables
    df_bkpf = read_sap_table(conn, class="hl-string">'BKPF', fields=[class="hl-string">'MANDT', class="hl-string">'BUKRS', class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BLART', class="hl-string">'BUDAT', class="hl-string">'CPUDT', class="hl-string">'CPUTM', class="hl-string">'USNAM', class="hl-string">'TCODE', class="hl-string">'STBLG', class="hl-string">'BSTAT'], options=bkpf_filter)
    df_bkpf[class="hl-string">'AWKEY'] = df_bkpf[class="hl-string">'BELNR'] + df_bkpf[class="hl-string">'GJAHR']
    df_bkpf[class="hl-string">'OBJECTKEY'] = df_bkpf[class="hl-string">'MANDT'] + df_bkpf[class="hl-string">'BUKRS'] + df_bkpf[class="hl-string">'BELNR'] + df_bkpf[class="hl-string">'GJAHR']
    doc_keys = df_bkpf[[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS']].drop_duplicates().to_dict(class="hl-string">'records')
    bseg_filter = class="hl-string">" OR ".join([fclass="hl-string">"(BELNR = '{k['BELNR']}' AND GJAHR = '{k['GJAHR']}' AND BUKRS = '{k['BUKRS']}')" for k in doc_keys])
    df_bseg = read_sap_table(conn, class="hl-string">'BSEG', fields=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS', class="hl-string">'BUZEI', class="hl-string">'LIFNR', class="hl-string">'ZFBDT', class="hl-string">'ZTERM', class="hl-string">'ZLSPR', class="hl-string">'WRBTR'])

    class=class="hl-string">"hl-comment"># Extract more tables based on findings
    rseg_filter = [fclass="hl-string">"BELNR IN ({','.join(df_bkpf['BELNR'].unique())}) AND GJAHR IN ({','.join(df_bkpf['GJAHR'].unique())})"]
    df_rseg = read_sap_table(conn, class="hl-string">'RSEG', fields=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'EBELN', class="hl-string">'EBELP', class="hl-string">'LFBNR'])
    
    vendor_numbers = df_bseg[class="hl-string">'LIFNR'].dropna().unique()
    lfa1_filter = [fclass="hl-string">"LIFNR IN ({','.join(vendor_numbers)})"]
    df_lfa1 = read_sap_table(conn, class="hl-string">'LFA1', fields=[class="hl-string">'LIFNR', class="hl-string">'NAME1'])

    class=class="hl-string">"hl-comment"># Change Documents (CDHDR/CDPOS) for Payment Blocks
    cdhdr_filter = [fclass="hl-string">"OBJECTCLAS = 'BELEGV' AND OBJECTID IN ({','.join(df_bkpf['OBJECTKEY'].unique())}) AND TCODE = 'FB02'"]
    df_cdhdr = read_sap_table(conn, class="hl-string">'CDHDR', fields=[class="hl-string">'OBJECTCLAS', class="hl-string">'OBJECTID', class="hl-string">'CHANGENR', class="hl-string">'USERNAME', class="hl-string">'UDATE', class="hl-string">'UTIME'])
    cdpos_filter = [fclass="hl-string">"OBJECTCLAS = 'BELEGV' AND FNAME = 'ZLSPR' AND TABNAME = 'BSEG' AND CHANGENR IN ({','.join(df_cdhdr['CHANGENR'].unique())})"]
    df_cdpos = read_sap_table(conn, class="hl-string">'CDPOS', fields=[class="hl-string">'CHANGENR', class="hl-string">'TABKEY', class="hl-string">'FNAME', class="hl-string">'VALUE_NEW', class="hl-string">'VALUE_OLD'])
    
    class=class="hl-string">"hl-comment"># Cleared Items
    bsak_filter = class="hl-string">" OR ".join([fclass="hl-string">"(BELNR = '{k['BELNR']}' AND GJAHR = '{k['GJAHR']}' AND BUKRS = '{k['BUKRS']}')" for k in doc_keys])
    df_bsak = read_sap_table(conn, class="hl-string">'BSAK', fields=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS', class="hl-string">'AUGDT', class="hl-string">'AUGBL'])

    class=class="hl-string">"hl-comment"># Payment Proposal
    regup_filter = class="hl-string">" OR ".join([fclass="hl-string">"(VBLNR = '{k['BELNR']}' AND GJAHR = '{k['GJAHR']}' AND BUKRS = '{k['BUKRS']}')" for k in doc_keys])
    df_regup = read_sap_table(conn, class="hl-string">'REGUP', fields=[class="hl-string">'LAUFD', class="hl-string">'LAUFI', class="hl-string">'VBLNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'])
    reguh_filter = [fclass="hl-string">"LAUFD IN ({','.join(df_regup['LAUFD'].unique())}) AND LAUFI IN ({','.join(df_regup['LAUFI'].unique())})"]
    df_reguh = read_sap_table(conn, class="hl-string">'REGUH', fields=[class="hl-string">'LAUFD', class="hl-string">'LAUFI', class="hl-string">'VBLNR'])


print(class="hl-string">"Extraction complete. Starting data transformation...")

class=class="hl-string">"hl-comment"># --- 4. DATA TRANSFORMATION & JOINING ---
class=class="hl-string">"hl-comment"># Merge core invoice data
df_inv = pd.merge(df_bkpf, df_bseg.loc[df_bseg[class="hl-string">'LIFNR'].notna()], on=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'])
df_inv = pd.merge(df_inv, df_lfa1, on=class="hl-string">'LIFNR', how=class="hl-string">'left')
df_inv = pd.merge(df_inv, df_rseg, on=[class="hl-string">'BELNR', class="hl-string">'GJAHR'], how=class="hl-string">'left')

class=class="hl-string">"hl-comment"># --- 5. EVENT LOG CREATION ---
all_events = []

class=class="hl-string">"hl-comment"># Invoice Document Created
df_created = df_inv.copy()
df_created[class="hl-string">'Activity'] = class="hl-string">'Invoice Document Created'
df_created[class="hl-string">'EventTime'] = pd.to_datetime(df_created[class="hl-string">'CPUDT'] + df_created[class="hl-string">'CPUTM'], format=class="hl-string">'%Y%m%d%H%M%S')
all_events.append(df_created)

class=class="hl-string">"hl-comment"># Invoice Parked
df_parked = df_inv[df_inv[class="hl-string">'BSTAT'] == class="hl-string">'V'].copy()
df_parked[class="hl-string">'Activity'] = class="hl-string">'Invoice Parked'
df_parked[class="hl-string">'EventTime'] = pd.to_datetime(df_parked[class="hl-string">'CPUDT'] + df_parked[class="hl-string">'CPUTM'], format=class="hl-string">'%Y%m%d%H%M%S')
all_events.append(df_parked)

class=class="hl-string">"hl-comment"># Purchase Order Matched
df_po_match = df_inv[df_inv[class="hl-string">'EBELN'].notna()].copy()
df_po_match[class="hl-string">'Activity'] = class="hl-string">'Purchase Order Matched'
df_po_match[class="hl-string">'EventTime'] = pd.to_datetime(df_po_match[class="hl-string">'CPUDT'] + df_po_match[class="hl-string">'CPUTM'], format=class="hl-string">'%Y%m%d%H%M%S')
all_events.append(df_po_match)

class=class="hl-string">"hl-comment"># Goods Receipt Matched
df_gr_match = df_inv[df_inv[class="hl-string">'LFBNR'].notna()].copy()
df_gr_match[class="hl-string">'Activity'] = class="hl-string">'Goods Receipt Matched'
df_gr_match[class="hl-string">'EventTime'] = pd.to_datetime(df_gr_match[class="hl-string">'CPUDT'] + df_gr_match[class="hl-string">'CPUTM'], format=class="hl-string">'%Y%m%d%H%M%S')
all_events.append(df_gr_match)

class=class="hl-string">"hl-comment"># Payment Block Set & Removed (from change logs)
if not df_cdhdr.empty and not df_cdpos.empty:
    df_changes = pd.merge(df_cdhdr, df_cdpos, on=class="hl-string">'CHANGENR')
    df_changes[class="hl-string">'BELNR'] = df_changes[class="hl-string">'OBJECTID'].str[7:17]
    df_changes[class="hl-string">'GJAHR'] = df_changes[class="hl-string">'OBJECTID'].str[17:21]
    df_changes[class="hl-string">'BUKRS'] = df_changes[class="hl-string">'OBJECTID'].str[3:7]
    df_changes = pd.merge(df_changes, df_inv[[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS']].drop_duplicates(), on=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'])
    
    df_block_set = df_changes[df_changes[class="hl-string">'VALUE_NEW'].str.strip() != class="hl-string">''].copy()
    df_block_set[class="hl-string">'Activity'] = class="hl-string">'Payment Block Set'
    df_block_set[class="hl-string">'EventTime'] = pd.to_datetime(df_block_set[class="hl-string">'UDATE'] + df_block_set[class="hl-string">'UTIME'], format=class="hl-string">'%Y%m%d%H%M%S')
    df_block_set.rename(columns={class="hl-string">'VALUE_NEW': class="hl-string">'PaymentBlockReason', class="hl-string">'USERNAME': class="hl-string">'ProcessorUser'}, inplace=True)
    all_events.append(df_block_set)

    df_block_removed = df_changes[df_changes[class="hl-string">'VALUE_OLD'].str.strip() != class="hl-string">''].copy()
    df_block_removed[class="hl-string">'Activity'] = class="hl-string">'Payment Block Removed'
    df_block_removed[class="hl-string">'EventTime'] = pd.to_datetime(df_block_removed[class="hl-string">'UDATE'] + df_block_removed[class="hl-string">'UTIME'], format=class="hl-string">'%Y%m%d%H%M%S')
    df_block_removed.rename(columns={class="hl-string">'VALUE_OLD': class="hl-string">'PaymentBlockReason', class="hl-string">'USERNAME': class="hl-string">'ProcessorUser'}, inplace=True)
    all_events.append(df_block_removed)

    class=class="hl-string">"hl-comment"># Invoice Routed For Approval & Approved (inferred from blocks)
    class=class="hl-string">"hl-comment"># Assumption: A specific block reason, e.g., class="hl-string">'A', signifies approval workflow.
    df_routed = df_block_set[df_block_set[class="hl-string">'PaymentBlockReason'].str.strip() == class="hl-string">'[A]'].copy()
    df_routed[class="hl-string">'Activity'] = class="hl-string">'Invoice Routed For Approval'
    all_events.append(df_routed)

    df_approved = df_block_removed[df_block_removed[class="hl-string">'PaymentBlockReason'].str.strip() == class="hl-string">'[A]'].copy()
    df_approved[class="hl-string">'Activity'] = class="hl-string">'Invoice Approved'
    df_approved[class="hl-string">'Approver'] = df_approved[class="hl-string">'ProcessorUser']
    all_events.append(df_approved)

class=class="hl-string">"hl-comment"># Invoice Posted
df_posted = df_inv[df_inv[class="hl-string">'BSTAT'] != class="hl-string">'V'].copy()
df_posted[class="hl-string">'Activity'] = class="hl-string">'Invoice Posted'
df_posted[class="hl-string">'EventTime'] = pd.to_datetime(df_posted[class="hl-string">'BUDAT'], format=class="hl-string">'%Y%m%d')
all_events.append(df_posted)

class=class="hl-string">"hl-comment"># Invoice Cleared By Payment
if not df_bsak.empty:
    df_cleared = pd.merge(df_inv, df_bsak[df_bsak[class="hl-string">'AUGDT'] != class="hl-string">'00000000'], on=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'])
    df_cleared[class="hl-string">'Activity'] = class="hl-string">'Invoice Cleared By Payment'
    df_cleared[class="hl-string">'EventTime'] = pd.to_datetime(df_cleared[class="hl-string">'AUGDT'], format=class="hl-string">'%Y%m%d')
    all_events.append(df_cleared)

class=class="hl-string">"hl-comment"># Invoice Reversed
df_reversed = df_inv[df_inv[class="hl-string">'STBLG'].notna() & (df_inv[class="hl-string">'STBLG'] != class="hl-string">'')].copy()
if not df_reversed.empty:
    reversal_docs = pd.merge(df_reversed, df_bkpf[[class="hl-string">'BELNR', class="hl-string">'BUDAT']], left_on=class="hl-string">'STBLG', right_on=class="hl-string">'BELNR', suffixes=(class="hl-string">'', class="hl-string">'_rev'))
    reversal_docs[class="hl-string">'Activity'] = class="hl-string">'Invoice Reversed'
    reversal_docs[class="hl-string">'EventTime'] = pd.to_datetime(reversal_docs[class="hl-string">'BUDAT_rev'], format=class="hl-string">'%Y%m%d')
    all_events.append(reversal_docs)

class=class="hl-string">"hl-comment"># Payment Proposal Created
if not df_regup.empty and not df_reguh.empty:
    df_proposal = pd.merge(df_regup, df_reguh, on=[class="hl-string">'LAUFD', class="hl-string">'LAUFI'])
    df_proposal = pd.merge(df_proposal, df_inv, left_on=[class="hl-string">'VBLNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'], right_on=[class="hl-string">'BELNR', class="hl-string">'GJAHR', class="hl-string">'BUKRS'])
    df_proposal[class="hl-string">'Activity'] = class="hl-string">'Payment Proposal Created'
    df_proposal[class="hl-string">'EventTime'] = pd.to_datetime(df_proposal[class="hl-string">'LAUFD'], format=class="hl-string">'%Y%m%d')
    all_events.append(df_proposal)

class=class="hl-string">"hl-comment"># Due Date Passed Without Payment (Calculated)
if not df_bsak.empty:
    cleared_keys = df_bsak[class="hl-string">'BELNR'] + df_bsak[class="hl-string">'GJAHR'] + df_bsak[class="hl-string">'BUKRS']
    df_open = df_inv[~(df_inv[class="hl-string">'BELNR'] + df_inv[class="hl-string">'GJAHR'] + df_inv[class="hl-string">'BUKRS']).isin(cleared_keys)].copy()
    df_open[class="hl-string">'DueDate'] = pd.to_datetime(df_open[class="hl-string">'ZFBDT'], format=class="hl-string">'%Y%m%d', errors=class="hl-string">'coerce')
    df_overdue = df_open[(df_open[class="hl-string">'DueDate'] < datetime.now()) & (df_open[class="hl-string">'DueDate'].notna())].copy()
    if not df_overdue.empty:
        df_overdue[class="hl-string">'Activity'] = class="hl-string">'Due Date Passed Without Payment'
        df_overdue[class="hl-string">'EventTime'] = df_overdue[class="hl-string">'DueDate']
        all_events.append(df_overdue)

class=class="hl-string">"hl-comment"># --- 6. FINAL ASSEMBLY & EXPORT ---
print(class="hl-string">"Assembling final event log...")

df_event_log = pd.concat(all_events, ignore_index=True, sort=False)

class=class="hl-string">"hl-comment"># Rename and select columns
column_mapping = {
    class="hl-string">'BELNR': class="hl-string">'InvoiceNumber',
    class="hl-string">'USNAM': class="hl-string">'ProcessorUser',
    class="hl-string">'NAME1': class="hl-string">'VendorName',
    class="hl-string">'BUKRS': class="hl-string">'CompanyCode',
    class="hl-string">'WRBTR': class="hl-string">'InvoiceGrossAmount',
    class="hl-string">'ZFBDT': class="hl-string">'InvoiceDueDate',
    class="hl-string">'ZTERM': class="hl-string">'PaymentTerms',
    class="hl-string">'EBELN': class="hl-string">'PurchaseOrderNumber',
    class="hl-string">'ZLSPR': class="hl-string">'PaymentBlockReason'
}
df_event_log.rename(columns=column_mapping, inplace=True)

class=class="hl-string">"hl-comment"># Ensure required columns exist
final_cols = [
    class="hl-string">'InvoiceNumber', class="hl-string">'Activity', class="hl-string">'EventTime', class="hl-string">'ProcessorUser', class="hl-string">'VendorName', 
    class="hl-string">'CompanyCode', class="hl-string">'InvoiceGrossAmount', class="hl-string">'InvoiceDueDate', class="hl-string">'PaymentTerms', 
    class="hl-string">'PurchaseOrderNumber', class="hl-string">'PaymentBlockReason', class="hl-string">'Approver'
]

for col in final_cols:
    if col not in df_event_log.columns:
        df_event_log[col] = None

df_final = df_event_log[final_cols].sort_values(by=[class="hl-string">'InvoiceNumber', class="hl-string">'EventTime']).reset_index(drop=True)

class=class="hl-string">"hl-comment"># Export to CSV
df_final.to_csv(class="hl-string">'sap_ap_event_log.csv', index=False)
print(fclass="hl-string">"Event log created successfully with {len(df_final)} events.")

Steps

Prerequisites & Setup: Install a certified third-party ETL tool (e.g., Theobald Xtract Universal, Talend with SAP Connector). Ensure you have a valid license and network connectivity to the SAP ECC system. Configure an SAP user account with necessary RFC and table read authorizations (e.g., access to S_RFC and S_TABU_DIS for the required tables).
Create SAP Connection: Within the ETL tool, create a new SAP connection. Provide the application server details, system ID, client number, and the credentials for the dedicated SAP user account. Test the connection to ensure it is successful.
Define Base Data Sources: Add the core SAP tables as data sources in your extraction job: BKPF (Accounting Document Header), BSEG (Accounting Document Segment), LFA1 (Vendor Master), RBKP (MM Invoice Header), RSEG (MM Invoice Line Item), CDHDR (Change Document Header), and CDPOS (Change Document Items).
Establish Table Joins: Create a base view or data flow by joining the tables. Join BKPF to BSEG on BUKRS, BELNR, and GJAHR. Join BKPF to LFA1 on LIFNR. Join BSEG to RSEG using the MM document info (BELNR, GJAHR mapped to RSEG.BELNR, RSEG.GJAHR). Join BKPF to CDHDR on OBJECTCLAS='BELEG' and OBJECTID = CompanyCode + DocumentNumber + FiscalYear.
Apply Global Filters: Apply filters at the source level to limit the data scope. Common filters include BKPF.BUKRS (Company Code), BKPF.GJAHR (Fiscal Year), and BKPF.BLART (Document Type, e.g., 'KR', 'RE'). It is critical to apply a date range filter on BKPF.CPUDT (Entry Date) to manage data volume.
Construct 'Invoice Document Created' Activity: Create the first data stream. Set Activity to 'Invoice Document Created'. The EventTime is a combination of BKPF.CPUDT (Date) and BKPF.CPUTM (Time). Select all required and recommended attributes from the joined tables.
Build Subsequent Activity Streams: For each of the remaining 12 activities, create a separate data stream or transformation path. Apply specific logic and filters to isolate the records for that event. For example, for 'Invoice Parked', filter for BKPF.BSTAT = 'V'. For events based on changes, filter CDHDR and CDPOS for the specific table, field, and value changes (e.g., FNAME = 'ZLSPL' for Payment Block).
Isolate Change Document Events: For activities like 'Payment Block Set' and 'Payment Block Removed', use the data from CDHDR and CDPOS. The EventTime will be CDHDR.UDATE and CDHDR.UTIME. The ProcessorUser is CDHDR.USERNAME.
Calculate 'Due Date Passed' Event: Create a dedicated transformation step to calculate this activity. The logic is: IF BSEG.AUGBL IS NULL AND CURRENT_DATE > BSEG.ZFBDT THEN create event. The EventTime for this activity should be set to the due date (BSEG.ZFBDT).
Union All Streams: Use a 'Union' or 'Merge' transformation in your ETL tool to combine all 13 individual activity streams into a single dataset. Ensure the column names, order, and data types are consistent across all streams before the union.
Final Formatting & Export: Review the final combined data set. Ensure the EventTime column is in a standard timestamp format (e.g., YYYY-MM-DD HH:MI:SS). Export the final event log as a CSV file with UTF-8 encoding, ready for upload into your process mining tool.

Configuration

ETL Tool & Connector: A licensed ETL tool with a certified SAP connector is required. This method relies on the tool's graphical interface for configuration, not direct ABAP or SQL coding.
SAP User Authorizations: The SAP user needs RFC execution permissions and display authorization for tables: BKPF, BSEG, LFA1, T001, T003T, RBKP, RSEG, CDHDR, CDPOS, REGUH, REGUP, and LFB1.
Date Range Filtering: Highly recommended to filter on an entry date field like BKPF.CPUDT for the initial load. A range of 6-12 months is typical for a first analysis. Subsequent loads can use a delta mechanism based on change dates.
Key Source Filters:
- BKPF.BUKRS (Company Code): Select specific company codes to focus the analysis.
- BKPF.BLART (Document Type): Filter for relevant invoice types, commonly 'KR' (Vendor Invoice) and 'RE' (MM Invoice Receipt).
Performance Considerations: Extracting from change document tables (CDHDR, CDPOS) can be resource-intensive. Apply specific filters on OBJECTCLAS = 'BELEG' and the relevant transaction codes (TCODE) to minimize performance impact. Avoid full table scans.

a Sample Query config

-- This is a logical representation of the ETL configuration.
-- Each 'SELECT' block represents a separate data stream for an activity,
-- which are then combined using a UNION ALL transformation in the ETL tool.

-- Base Data Source: A join of BKPF, BSEG, LFA1, RBKP, RSEG
-- Let's call this joined view 'INVOICE_DETAILS'

-- 1. Invoice Document Created
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, -- Case ID
    'Invoice Document Created' AS Activity,
    TO_TIMESTAMP(B.CPUDT, B.CPUTM) AS EventTime,
    B.USNAM AS ProcessorUser,
    L.NAME1 AS VendorName,
    B.BUKRS AS CompanyCode,
    B.WAERS AS Currency,
    (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, 
    S1.ZFBDT AS InvoiceDueDate, -- Due date from first line item
    S1.ZTERM AS PaymentTerms,
    S1.EBELN AS PurchaseOrderNumber,
    S1.ZLSPR AS PaymentBlockReason,
    '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' -- First vendor line item
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.CPUDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 2. Invoice Parked
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber,
    'Invoice Parked' AS Activity,
    TO_TIMESTAMP(B.CPUDT, B.CPUTM) AS EventTime,
    B.USNAM AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE B.BSTAT = 'V' AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.CPUDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 3. Purchase Order Matched
SELECT DISTINCT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber,
    'Purchase Order Matched' AS Activity, 
    TO_TIMESTAMP(B.CPUDT, B.CPUTM) AS EventTime, 
    B.USNAM AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE S1.EBELN IS NOT NULL AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.CPUDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 4. Goods Receipt Matched
SELECT DISTINCT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber,
    'Goods Receipt Matched' AS Activity, 
    TO_TIMESTAMP(B.CPUDT, B.CPUTM) AS EventTime, 
    B.USNAM AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN RSEG AS R ON S1.BELNR = R.BELNR AND S1.GJAHR = R.GJAHR
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE R.LFBNR IS NOT NULL AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.CPUDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 5. Payment Block Set
SELECT
    CONCAT(SUBSTRING(H.OBJECTID, 1, 4), SUBSTRING(H.OBJECTID, 5, 10), SUBSTRING(H.OBJECTID, 15, 4)) AS InvoiceNumber,
    'Payment Block Set' AS Activity,
    TO_TIMESTAMP(H.UDATE, H.UTIME) AS EventTime,
    H.USERNAME AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, P.VALUE_NEW AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM CDHDR H
JOIN CDPOS P ON H.CHANGENR = P.CHANGENR
JOIN BKPF B ON SUBSTRING(H.OBJECTID, 5, 10) = B.BELNR AND SUBSTRING(H.OBJECTID, 1, 4) = B.BUKRS AND SUBSTRING(H.OBJECTID, 15, 4) = B.GJAHR
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE H.OBJECTCLAS = 'BELEG' AND P.TABNAME = 'BSEG' AND P.FNAME = 'ZLSPR' AND P.VALUE_NEW <> ''
AND B.BUKRS = '[YourCompanyCode]' AND H.UDATE BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 6. Invoice Routed For Approval (Inferred from specific block)
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Invoice Routed For Approval' AS Activity, TO_TIMESTAMP(H.UDATE, H.UTIME) AS EventTime, H.USERNAME AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, P.VALUE_NEW AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM CDHDR H JOIN CDPOS P ON H.CHANGENR = P.CHANGENR JOIN BKPF B ON SUBSTRING(H.OBJECTID, 5, 10) = B.BELNR AND SUBSTRING(H.OBJECTID, 1, 4) = B.BUKRS AND SUBSTRING(H.OBJECTID, 15, 4) = B.GJAHR JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE H.OBJECTCLAS = 'BELEG' AND P.TABNAME = 'BSEG' AND P.FNAME = 'ZLSPR' AND P.VALUE_NEW = '[ApprovalBlockReasonCode]'
AND B.BUKRS = '[YourCompanyCode]' AND H.UDATE BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 7. Invoice Approved (Inferred from removal of specific block)
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Invoice Approved' AS Activity, TO_TIMESTAMP(H.UDATE, H.UTIME) AS EventTime, H.USERNAME AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, '' AS PaymentBlockReason, H.USERNAME AS Approver
FROM CDHDR H JOIN CDPOS P ON H.CHANGENR = P.CHANGENR JOIN BKPF B ON SUBSTRING(H.OBJECTID, 5, 10) = B.BELNR AND SUBSTRING(H.OBJECTID, 1, 4) = B.BUKRS AND SUBSTRING(H.OBJECTID, 15, 4) = B.GJAHR JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE H.OBJECTCLAS = 'BELEG' AND P.TABNAME = 'BSEG' AND P.FNAME = 'ZLSPR' AND P.VALUE_OLD = '[ApprovalBlockReasonCode]' AND P.VALUE_NEW = ''
AND B.BUKRS = '[YourCompanyCode]' AND H.UDATE BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 8. Payment Block Removed
SELECT
    CONCAT(SUBSTRING(H.OBJECTID, 1, 4), SUBSTRING(H.OBJECTID, 5, 10), SUBSTRING(H.OBJECTID, 15, 4)) AS InvoiceNumber, 'Payment Block Removed' AS Activity, TO_TIMESTAMP(H.UDATE, H.UTIME) AS EventTime, H.USERNAME AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, '' AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM CDHDR H JOIN CDPOS P ON H.CHANGENR = P.CHANGENR JOIN BKPF B ON SUBSTRING(H.OBJECTID, 5, 10) = B.BELNR AND SUBSTRING(H.OBJECTID, 1, 4) = B.BUKRS AND SUBSTRING(H.OBJECTID, 15, 4) = B.GJAHR JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE H.OBJECTCLAS = 'BELEG' AND P.TABNAME = 'BSEG' AND P.FNAME = 'ZLSPR' AND P.VALUE_NEW = '' AND P.VALUE_OLD <> ''
AND B.BUKRS = '[YourCompanyCode]' AND H.UDATE BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 9. Invoice Posted (Change from Parked to Posted)
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Invoice Posted' AS Activity, TO_TIMESTAMP(H.UDATE, H.UTIME) AS EventTime, H.USERNAME AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM CDHDR H JOIN CDPOS P ON H.CHANGENR = P.CHANGENR JOIN BKPF B ON SUBSTRING(H.OBJECTID, 5, 10) = B.BELNR AND SUBSTRING(H.OBJECTID, 1, 4) = B.BUKRS AND SUBSTRING(H.OBJECTID, 15, 4) = B.GJAHR JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE H.OBJECTCLAS = 'BELEG' AND P.TABNAME = 'BKPF' AND P.FNAME = 'BSTAT' AND P.VALUE_OLD = 'V' AND P.VALUE_NEW = ''
AND B.BUKRS = '[YourCompanyCode]' AND H.UDATE BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 10. Due Date Passed Without Payment (Calculated)
SELECT 
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Due Date Passed Without Payment' AS Activity, TO_TIMESTAMP(S1.ZFBDT) AS EventTime, 'SYSTEM' AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K' JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE S1.AUGBL IS NULL AND S1.ZFBDT < CURRENT_DATE
AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.CPUDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 11. Payment Proposal Created
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Payment Proposal Created' AS Activity, TO_TIMESTAMP(H.LAUFD) AS EventTime, H.USNAM AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM REGUH H
JOIN REGUP P ON H.LAUFD = P.LAUFD AND H.LAUFI = P.LAUFI AND H.XVORL = P.XVORL
JOIN BKPF B ON P.BUKRS = B.BUKRS AND P.BELNR = B.BELNR AND P.GJAHR = B.GJAHR
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE B.BUKRS = '[YourCompanyCode]' AND H.LAUFD BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 12. Invoice Cleared By Payment
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Invoice Cleared By Payment' AS Activity, TO_TIMESTAMP(S1.AUGDT) AS EventTime, B.USNAM AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, '' AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE S1.AUGBL IS NOT NULL
AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND S1.AUGDT BETWEEN '[StartDate]' AND '[EndDate]'

UNION ALL

-- 13. Invoice Reversed
SELECT
    CONCAT(B.BUKRS, B.BELNR, B.GJAHR) AS InvoiceNumber, 'Invoice Reversed' AS Activity, TO_TIMESTAMP(B.STODT) AS EventTime, B.USNAM_REV AS ProcessorUser, L.NAME1 AS VendorName, B.BUKRS AS CompanyCode, B.WAERS AS Currency, (SELECT SUM(WRBTR) FROM BSEG S WHERE S.BELNR = B.BELNR AND S.GJAHR = B.GJAHR AND S.BUKRS = B.BUKRS) AS InvoiceGrossAmount, S1.ZFBDT AS InvoiceDueDate, S1.ZTERM AS PaymentTerms, S1.EBELN AS PurchaseOrderNumber, S1.ZLSPR AS PaymentBlockReason, '[Workflow Approver]' AS Approver
FROM BKPF AS B
JOIN BSEG AS S1 ON B.BELNR = S1.BELNR AND B.GJAHR = S1.GJAHR AND B.BUKRS = S1.BUKRS AND S1.KOART = 'K'
JOIN LFA1 AS L ON B.LIFNR = L.LIFNR
WHERE B.STBLG IS NOT NULL
AND B.BLART IN ('KR', 'RE') AND B.BUKRS = '[YourCompanyCode]' AND B.STODT BETWEEN '[StartDate]' AND '[EndDate]'

Data Template: Accounts Payable Invoice Processing

Your Accounts Payable Invoice Processing Data Template

Accounts Payable Invoice Processing Attributes

Accounts Payable Invoice Processing Activities

Extraction Guides

Custom ABAP Program for AP Invoice Data Extraction

Steps

Configuration

a Sample Query abap

Direct SQL Query on SAP ECC Underlying Database

Steps

Configuration

a Sample Query sql

Python Script Extraction via SAP RFC Protocol

Steps

Configuration

a Sample Query python

ETL Tool with Certified SAP Connector (e.g., Theobald)

Steps

Configuration

a Sample Query config

Ready to Get Started?

Stop Late Fees: Optimize Accounts Payable Now & Save 60%