SAP PI / PO Integration

File Content
Conversion

Transform flat files into structured XML and back — the definitive guide to configuring File Content Conversion in SAP Process Integration & Process Orchestration.

1 ⚙️
Set Configuration Name & Separators
2 📥
Enter / Paste Input Here CSV, Fixed-Length, or XML
3
Click Convert Run Engine
4 🌲
Get Output Copy XML / Flat File

Configuration

Format: StructureName,Count — use * for unbounded
Order
Flat File Input
XML Output
Live Transform Pipeline

Visual Conversion Engine

CSV
📄
Flat Input
0 Lines
FCC Engine
MT_Orders Sep: ,
XML
🌲
XML Output
0 Nodes
💡 Configure your parameters and paste your data, then click Convert.

File Content Conversion

File content conversion is the process of transforming data from one file format into another — for example, converting a flat file (CSV, fixed-length text) into XML, or converting XML back into a flat file — so that systems with different data format requirements can exchange information without errors. In the SAP ecosystem, this process is handled natively by the File Content Conversion (FCC) module inside the File Adapter of SAP Process Integration (PI) and Process Orchestration (PO), without requiring custom message mappings for basic transformations.

The 3 main benefits of file content conversion are reduced development effort, faster data exchange between disparate systems, and consistent payload structure across enterprise integration layers. Its 3 primary use cases are inbound flat file processing (CSV to XML), outbound XML-to-flat-file transformation, and secure data exchange using Pretty Good Privacy (PGP) encryption and decryption.

File content conversion has 4 key components: the File Adapter, FCC parameters (such as fieldSeparator and recordsetStructure), adapter modules (such as Localejbs/PGPDecryption and AF_Modules/MessageTransformBean), and the Message Mapping layer used for complex transformations when FCC alone is insufficient.

Flat File Parsing

Parse CSV, fixed-length, and delimiter-separated flat files into structured XML documents using configurable field definitions.

Adapter Integration

Works natively with File and FTP adapters. Can also be applied to other adapters using the MessageTransformBean module.

Multi-Structure

Support for complex file structures with multiple record types — headers, detail lines, and footers in a single file.

Bidirectional

Convert in both directions — from flat files to XML (Sender) and from XML back to flat files (Receiver).

Flat File
XML Data
Reduced Dev Effort
Faster Exchange
Consistent Payload

What is File Content Conversion?

File content conversion is the automated transformation of a file's data structure from one format to another — most commonly from a non-XML format like CSV or fixed-length text into structured XML, or the reverse. This conversion happens at the adapter level before the data enters the integration pipeline.

In practical terms, a sender system drops a flat file into a directory. The integration middleware picks it up, reads its structure using configured parameters, and outputs a well-formed XML document that downstream systems can process. No manual reformatting is required.

File content conversion handles 3 main transformation directions:

  • Flat file to XML (inbound processing, sender side)
  • XML to flat file (outbound processing, receiver side)
  • Flat file to XML with PGP-encrypted source files (combined decryption + conversion)

The term “flat file” covers any non-XML file, including comma-separated values (CSV) files, pipe-delimited files, tab-separated files, and fixed-length text files.

FCC Engine
Flat File → XML
XML → Flat File
PGP File → XML
Select a path

How It Works

FCC operates within the Communication Channel's adapter module chain, converting data as it flows through SAP PI/PO's integration framework.

01

Source System

A flat file (CSV, TXT, DAT, or fixed-length) is placed in a directory or sent via FTP by the source system.

02

File/FTP Adapter (Sender)

The sender adapter picks up the file. Message Protocol is set to "File Content Conversion". FCC parameters define the file structure.

03

Content Conversion Engine

FCC processes the flat file line-by-line, applying field separators, key fields, and structure definitions to produce a well-formed XML document.

04

Integration Engine

The XML message enters SAP PI/PO's Integration Engine for routing, mapping, and transformation as needed.

05

Target System

The processed message is delivered to the target system — optionally converted back to a flat file via Receiver FCC.

What Is File Content Conversion in SAP PI/PO?

File Content Conversion in SAP Process Integration (PI) / Process Orchestration (PO) is a built-in feature of the File Adapter that converts flat files into XML — or XML into flat files — at runtime, without requiring message mapping for the conversion step itself.

SAP PI/PO serves as middleware technology connecting SAP ERP, CRM, SCM, and third-party systems within SAP-centric enterprises. When these systems exchange data, they often use different file formats. File content conversion solves the format compatibility problem at the adapter layer.

SAP PI/PO provides this functionality out of the box for unencrypted files. When the file is encrypted using PGP, additional adapter modules handle decryption before the FCC module processes the content.

The configuration takes place in two locations:

  • Enterprise Services Repository (ESR): where data types, message types, service interfaces, and message mappings are created
  • Integration Directory (ID): where communication channels, sender/receiver agreements, and Integrated Configuration (ICO) objects are configured

File content conversion in SAP PI is used for integrations where an external system sends a CSV file and SAP needs to parse it as XML, or where SAP sends XML data that a legacy system expects in flat file format.

ESR

Data Types
Message Types
Service Interfaces
Message Mappings

ID

Comm. Channels
Sender Agreements
Receiver Agreements
ICO
Click an item for details

What Is FCC (File Content Conversion) Module?

The File Content Conversion (FCC) module is a standard component within SAP PI/PO's File Adapter that processes flat file payloads during runtime, converting them to or from XML based on configured parameters.

FCC operates inside the SAP adapter engine at the communication channel level. It intercepts the file payload before the message enters the integration flow and applies the conversion rules defined in the FCC parameters.

There are 2 types of FCC modules:

Sender FCC — reads flat files from a source directory and converts them into XML for inbound interface processing. This is configured in the sender communication channel.

Receiver FCC — receives XML from the integration flow and converts it into a flat file for outbound interface delivery. This is configured in the receiver communication channel.

FCC is the preferred approach for simple file-to-XML transformations in SAP NetWeaver PI/PO environments because it eliminates the need for dedicated Graphical Message Mapping objects for format conversion. Complex transformations that involve business logic still require Message Mapping.

Sender
Receiver

How File Content Conversion Works

File Content Conversion follows a 5-step technical flow inside SAP PI/PO.

1 Flat File Input

A flat file (CSV, pipe-delimited, or fixed-length) is placed in the source directory. The file contains records separated by delimiters, with each line representing a data row.

2 Adapter Engine Processing

The SAP File Adapter polls the source directory at configured intervals. When it detects a file, it picks it up and passes it to the FCC module within the adapter engine.

3 FCC Parameter Processing

The FCC module reads the configured parameters — including fieldSeparator, recordsetStructure, documentName, and keyFieldName — and applies them to parse each record and field in the file.

4 XML Structure Generation

The FCC module maps each field to a corresponding XML element tag. For example, a CSV line 101,John,5000 becomes <Record><ID>101</ID><Name>John</Name><Amount>5000</Amount></Record> in the output XML.

5 Message Mapping & Delivery

The generated XML enters the integration pipeline where optional Message Mapping applies further business logic transformations before the message is delivered to the target system.

For encrypted files, PGP decryption runs before Step 3, using the Localejbs/PGPDecryption adapter module.

📄
Flat File Input
Raw text data arrives.
⚙️
Adapter Engine
Picks up the file.
🎛️
FCC Parameters
Parses based on config.
📝
XML Generation
Converts to XML format.
🚀
Mapping & Delivery
Sent to PI pipeline.

FCC Configuration in SAP PI/PO

To configure File Content Conversion, follow these 5 steps inside the Integration Directory.

1 Create Communication Channel

Open the Integration Directory and create a new communication channel. Assign it to the sender or receiver business component depending on whether the interface is inbound or outbound. Name the channel clearly to reflect its purpose, such as FC_Sender_EmployeeFile.

2 Select File Adapter

In the communication channel configuration, select File Adapter as the adapter type. The File Adapter handles file reading from source directories (sender) and file writing to target directories (receiver). Set the source directory path, filename pattern, and polling interval for sender channels.

3 Enable Content Conversion

Go to the Content Conversion tab within the File Adapter configuration. Set the Message Protocol to File Content Conversion. This activates the FCC module inside the adapter engine and enables payload conversion at runtime.

4 Maintain FCC Parameters

Configure the FCC parameters to match the structure of the flat file being processed. Required entries include:

  • Document Name: matches the root XML tag and should correspond to the message type name in ESR
  • Document Namespace: matches the namespace of the ESR message type
  • Recordset Structure: defines the names and occurrence counts of substructures
  • Record.fieldSeparator: specifies the delimiter used between fields
  • Record.fieldNames: lists the field names in the same order as they appear in the file

5 Activate and Test

Save and activate the communication channel. Place a sample flat file in the source directory. Use SAP PI's message monitoring to verify that the file is picked up, converted to XML correctly, and passed through the integration flow without errors.

FCC Parameters

Complete reference of all File Content Conversion parameters organized by category. Click any category to explore its parameters in detail.

Parameter Description Example Required
Document Name Name of the root element in the XML document. Must match the Message Type name in ESR. MT_SalesOrder Yes
Document Namespace XML namespace of the root element. Must match the namespace in ESR. urn:sap:xi:sales Yes
Document Offset Number of lines to skip at the beginning of the document before processing. 1 No
Parameter Description Example Required
Recordset Name Name of the wrapper element that contains all recordsets in the generated XML. Recordset Yes
Recordset Namespace Namespace for the recordset wrapper element. No
Recordset Structure Defines the structure names and their occurrence. Comma-separated list of structure name and count pairs. Header,1,Item,* Yes
Recordset Sequence Specifies whether structures appear in a fixed order (ascending) or any order. ascending No
Recordset Per Message Number of recordsets per XML message. Use * for all records in one message. * No
Key Field Name The field used to differentiate record types (e.g., which lines are Headers vs. Items). RecordType Conditional
Key Field Type Specifies whether the key field is identified by its value or by its position. fieldContent Conditional
Parameter Description Example Required
<Node>.fieldNames Comma-separated list of field names for this structure. Becomes XML element names. OrderID,Date,Amount Yes
<Node>.fieldSeparator The delimiter character separating fields. Use 0x09 for tab. , or ; Conditional
<Node>.fieldFixedLengths Comma-separated field lengths for fixed-width files. Alternative to fieldSeparator. 10,20,8,15 Conditional
<Node>.endSeparator End-of-line character. Use 'nl' for newline, 'rn' for carriage return + newline. 'nl' Yes
<Node>.keyFieldValue The value that identifies this structure's record type in the key field column. H or D Conditional
<Node>.processFieldNames How field names are determined. Set to fromConfiguration to use names from the config. fromConfiguration No
Parameter Description Example Required
<Node>.missingLastFields How to handle lines with fewer fields than expected. add adds empty fields; error raises an exception. add No
<Node>.additionalLastFields How to handle lines with more fields than expected. ignore drops extra fields. ignore No
<Node>.addHeaderLine Specifies a fixed header line to add at the beginning of the output (Receiver FCC). 0 No
<Node>.fieldContentFormatting Formatting rules applied to field content. Use trim to remove whitespace. trim No
<Node>.enclosureSign Character used to enclose field values, e.g., double quotes for CSV with embedded delimiters. " No
<Node>.enclosureSignEnd Closing enclosure character if different from the opening enclosure sign. " No
<Node>.enclosureConversion How enclosure signs are handled. Options: always, conditional. always No

Important FCC Parameters Explained

There are 7 key FCC parameters that control flat file parsing and XML generation in SAP PI/PO.

H;INV-001;2024-01-20;ACME Corp
keyFieldValue
fieldSeparator
fieldNames[1]
fieldNames[2]
fieldNames[3]

1. fieldSeparator

fieldSeparator specifies the character that separates individual fields within a record. Common values are , for CSV files, | for pipe-delimited files, and \t for tab-separated files.

Example: For a file containing 101,John,Engineering, set Record.fieldSeparator=, to split the line into three separate field values.

2. recordsetStructure

recordsetStructure defines the names and occurrence counts of substructures within each recordset. The format is NameA,nA,NameB,nB,... where n is a fixed count or * for unlimited occurrences.

Example: recordsetStructure=Header,1,Detail,*,Footer,1 defines a structure with one header, unlimited detail rows, and one footer per recordset.

3. keyFieldName

keyFieldName identifies the field used to distinguish between different substructure types when the recordset contains variable-count substructures. This field must appear in every substructure with a unique constant value per type.

Example: If Record.keyFieldName=RecType and RecType=H identifies headers while RecType=D identifies details, FCC uses this field to route each line to the correct substructure.

4. ignoreRecordsetName

ignoreRecordsetName controls whether the <Recordset> wrapper element is included in the output XML. Set to true to remove the wrapping element, which simplifies the XML structure when only one substructure type exists.

Example: ignoreRecordsetName=true removes the outer <Recordset> tag, leaving only the inner field elements in the XML.

5. addHeaderLine

addHeaderLine specifies whether the first line of the file is a header row that should be skipped during conversion. Set to true to exclude the header line from the XML output.

Example: A file starting with EmployeeID,Name,Department uses addHeaderLine=true so those column names are not converted as data records.

6. documentName

documentName sets the root XML element name in the generated XML document. This must match the message type name in ESR to ensure correct Message Mapping.

Example: documentName=EmployeeData produces <EmployeeData>...</EmployeeData> as the root element of the output XML.

7. xml.recordsetStructure

xml.recordsetStructure defines the XML element name that wraps each recordset in the output. This controls the second-level XML element structure below the document root.

Example: xml.recordsetStructure=EmployeeRecord produces <EmployeeRecord>...</EmployeeRecord> for each parsed row.

Correctly configuring these 7 parameters ensures clean XML output and prevents runtime errors during payload conversion in SAP PI/PO.

See It in Action

Explore real-world FCC configurations with input files and their resulting XML output.

input_orders.csv
1001,2024-01-15,John Smith,1500.00
1002,2024-01-16,Jane Doe,2300.50
1003,2024-01-17,Bob Wilson,890.75
output.xml
<?xml version="1.0"?>
<ns:MT_Orders xmlns:ns="urn:sap:orders">
  <Recordset>
    <Order>
      <OrderID>1001</OrderID>
      <Date>2024-01-15</Date>
      <Customer>John Smith</Customer>
      <Amount>1500.00</Amount>
    </Order>
    <Order>
      <OrderID>1002</OrderID>
      <Date>2024-01-16</Date>
      <Customer>Jane Doe</Customer>
      <Amount>2300.50</Amount>
    </Order>
    <Order>
      <OrderID>1003</OrderID>
      <Date>2024-01-17</Date>
      <Customer>Bob Wilson</Customer>
      <Amount>890.75</Amount>
    </Order>
  </Recordset>
</ns:MT_Orders>

FCC Configuration

Document NameMT_Orders
Document Namespaceurn:sap:orders
Recordset StructureOrder,*
Order.fieldNamesOrderID,Date,Customer,Amount
Order.fieldSeparator,
Order.endSeparator'nl'
employees.dat
E001  John Smith         Engineering   85000
E002  Maria Garcia        Marketing     72000
E003  Alex Johnson        Finance       91000
output.xml
<?xml version="1.0"?>
<ns:MT_Employees xmlns:ns="urn:sap:hr">
  <Recordset>
    <Employee>
      <EmpID>E001</EmpID>
      <Name>John Smith</Name>
      <Department>Engineering</Department>
      <Salary>85000</Salary>
    </Employee>
    <!-- ... more records -->
  </Recordset>
</ns:MT_Employees>

FCC Configuration

Document NameMT_Employees
Document Namespaceurn:sap:hr
Recordset StructureEmployee,*
Employee.fieldNamesEmpID,Name,Department,Salary
Employee.fieldFixedLengths6,20,14,5
Employee.fieldContentFormattingtrim
invoice.txt
H;INV-2024-001;2024-01-20;ACME Corp
D;PROD-A;Widget Alpha;50;12.99
D;PROD-B;Widget Beta;30;24.50
F;2;1384.50
output.xml
<?xml version="1.0"?>
<ns:MT_Invoice xmlns:ns="urn:sap:billing">
  <Recordset>
    <Header>
      <RecType>H</RecType>
      <InvoiceNo>INV-2024-001</InvoiceNo>
      <Date>2024-01-20</Date>
      <Customer>ACME Corp</Customer>
    </Header>
    <Detail>
      <RecType>D</RecType>
      <ProductID>PROD-A</ProductID>
      <Description>Widget Alpha</Description>
      <Qty>50</Qty>
      <Price>12.99</Price>
    </Detail>
    <Detail>
      <RecType>D</RecType>
      <ProductID>PROD-B</ProductID>
      <Description>Widget Beta</Description>
      <Qty>30</Qty>
      <Price>24.50</Price>
    </Detail>
    <Footer>
      <RecType>F</RecType>
      <TotalItems>2</TotalItems>
      <TotalAmount>1384.50</TotalAmount>
    </Footer>
  </Recordset>
</ns:MT_Invoice>

FCC Configuration

Document NameMT_Invoice
Document Namespaceurn:sap:billing
Recordset StructureHeader,1,Detail,*,Footer,1
Key Field NameRecType
Header.fieldNamesRecType,InvoiceNo,Date,Customer
Header.fieldSeparator;
Header.keyFieldValueH
Detail.fieldNamesRecType,ProductID,Description,Qty,Price
Detail.fieldSeparator;
Detail.keyFieldValueD
Footer.fieldNamesRecType,TotalItems,TotalAmount
Footer.fieldSeparator;
Footer.keyFieldValueF

Best Practices

Avoid common pitfalls and optimize your FCC configurations with these expert recommendations.

Case Sensitivity Matters

Parameter names and structure names are case-sensitive. Ensure that structure names in RecordsetStructure exactly match the structure names used in field-level parameters like Header.fieldNames.

Verify End Separators

Invisible characters cause most FCC failures. Always verify whether your source file uses 'nl' (Unix/Linux) or 'rn' (Windows) line endings. Open the file in a hex editor if unsure.

Match ESR Structures

Your Data Type in the Enterprise Service Repository (ESR) must exactly match the XML structure that FCC generates. Design your Data Type first, then configure FCC accordingly.

Handle Missing Fields

Use missingLastFields = add to gracefully handle lines with fewer fields than expected, instead of letting the conversion fail with an error.

Test with Real Data

Always test FCC with actual production-like data files. Sample files in different editors may have different encoding and line endings that won't surface in simplified testing.

Use MessageTransformBean

For adapters that don't natively support FCC (like REST, SOAP, or JMS), use the MessageTransformBean adapter module to apply content conversion within the module chain.

Best Practices for FCC Implementation

There are 5 best practices for reliable File Content Conversion implementations in SAP PI/PO.

1 Validate Flat Files Before Processing

Inspect source files for consistent delimiters, correct encoding, and expected record counts before deploying a new FCC channel. Pre-conversion schema validation catches structural problems before they cause runtime failures.

2 Use Consistent Recordset Structures

Define and enforce a fixed file layout with partners and upstream systems. Variable or inconsistent file structures require complex keyFieldName configurations and increase the chance of parsing errors.

3 Test with Small Datasets First

Run FCC configuration tests using files containing 5–10 records before processing production volumes. Sequential batch processing of large files is easier to troubleshoot when the basic configuration is proven correct on small samples.

4 Enable Message Monitoring and Logging

Turn on message monitoring in SAP PI/PO for all FCC channels. Automated error correction logging and runtime monitoring catch misconfigurations early, especially when file formats change without notice from source systems.

5 Document All FCC Parameters

Maintain a configuration document that records every FCC parameter value, the field mapping logic, and the expected file format for each channel. This documentation is essential for Legacy Application Modernization Services projects and SAP Transformation initiatives where FCC channels are migrated or rebuilt.

Sender vs Receiver FCC — Key Differences

Sender FCC and Receiver FCC serve opposite purposes in the data flow. Sender FCC converts flat files into XML during inbound processing; Receiver FCC converts XML into flat files for outbound delivery.

Feature Sender FCC Receiver FCC
Purpose Converts flat file to XML Converts XML to flat file
Interface direction Inbound interface Outbound interface
Configuration location Sender communication channel Receiver communication channel
Use case Reading CSV/flat files from external systems Writing flat files to legacy systems
Data flow File → FCC → XML → Integration Flow Integration Flow → XML → FCC → File

Choosing the correct FCC type is the first decision in any file integration design. Selecting the wrong type results in conversion failures at runtime or malformed output files.

Sender FCC
File
FCC
XML
Pipeline
Receiver FCC
Pipeline
XML
FCC
File

File Content Conversion in Sender Adapter

The sender file adapter uses FCC to read a flat file and produce XML. The FCC module processes the file line by line, applies the configured parsing rules, and outputs a structured XML document that the integration flow can map and route.

File Structure

The system expects a file with one or more logical structures called recordsets. Each recordset can contain one or multiple substructure types, identified by logical names. A substructure always maps to exactly one line in the source file.

The generated XML follows this structure:

<documentName>
  <recordset>
    <NameA>
      <field-nameA1>value</field-nameA1>
      <field-nameA2>value</field-nameA2>
    </NameA>
    <NameB>
      <field-nameB1>value</field-nameB1>
    </NameB>
  </recordset>
</documentName>

Handling Structure Deviations

Structure deviations occur when the actual file contains fewer or more fields than the configured structure specifies. FCC handles these cases using 2 parameters:

NameA.missingLastFields — controls behavior when the inbound structure has fewer fields than configured. Set to ignore to output only the present fields, add to output empty tags for missing fields, or error to terminate conversion.

NameA.additionalLastFields — controls behavior when the inbound structure has more fields than configured. Set to ignore to discard extra fields or error to terminate conversion. The default is ignore.

Document Specifications

4 document-level parameters must be set for correct Message Mapping:

  • Document Name: the root XML tag name, matching the ESR message type
  • Document Namespace: the namespace added to the document root element
  • Document Offset: the number of header lines to skip before reading data; default is 0
  • Recordset Name: the name of the recordset structure element in the XML

Parameters for Recordset Structures

Each substructure in the recordset requires its own set of parameters prefixed with the substructure name. The 5 core per-substructure parameters are:

  • NameA.fieldSeparator — delimiter between fields in this substructure
  • NameA.fieldNames — comma-separated list of field names, in file order
  • NameA.fieldFixedLengths — field widths in characters (for fixed-length files only)
  • NameA.keyFieldValue — the constant value of the key field that identifies this substructure type
  • NameA.endSeparator — optional character string after the last field in a row

For fixed-length files, fieldFixedLengths replaces fieldSeparator. Both can coexist, but the separator's length is not added to the fixed-length count.

FCC Output XML Structure

FCC with PGP in SAP PI/PO

Standard File Content Conversion in SAP PI/PO only works with unencrypted files. When source files are encrypted using Pretty Good Privacy (PGP) — a public-key encryption system that uses paired public and private keys for data encryption and data decryption — the default FCC function in the File Adapter cannot process the payload directly.

The solution uses adapter modules in the sender channel to decrypt the file first, then convert it to XML. On the receiver side, additional adapter modules convert XML to CSV and then encrypt the output file.

Sender Communication Channel (3 Modules)

Configure 3 adapter modules in the sender communication channel, in this exact sequence:

1 Localejbs/PGPDecryption

Decrypts the PGP-encrypted file using the private key. This module must run first so that FCC receives a plain-text payload.

2 AF_Modules/MessageTransformBean

Converts the decrypted flat file content into XML with the first line placed in a single segment. This module runs after decryption.

3 CallSAPAdapter

The default channel module. This must always be the last module in the sequence.

Message Mapping with Advanced UDF

Create a Message Mapping in ESR that maps the sender data type to the receiver data type. Define an Advanced User Defined Function (UDF) that takes the entire Record line as a string input, splits the string on the configured delimiter, and returns specific fields by index position.

Receiver Communication Channel (2 Modules)

Configure 2 adapter modules in the receiver communication channel:

1 Localejbs/AF_Modules/StrictXml2PlainBean

Converts the XML payload received from the integration flow into CSV format.

2 Localejbs/PGPEncryption

Encrypts the CSV output using the public key of the target recipient, producing a PGP-encrypted file.

Note: The default File Content Conversion function provided by SAP PI/PO's File Adapter does not work with PGP-encrypted messages. Always use the adapter module approach for encrypted file scenarios.

Module Chain Processing

Sender Channel
🔒
🔒
PGP Decryption
📄
MessageTransformBean
CallSAPAdapter
Click a module for details
Receiver Channel
📄
📄
StrictXml2PlainBean
🔒
PGP Encryption
Click a module for details

Common Errors in File Content Conversion

There are 5 common errors in FCC implementations, each tied to a specific misconfiguration.

Wrong Field Separator

Setting a comma separator on a pipe-delimited file causes FCC to treat each entire line as a single field, producing a single XML element with the full raw line as its value. Always verify the actual delimiter in the source file before configuring fieldSeparator.

Mismatched Field Count

When the number of fields in fieldNames does not match the actual number of fields in the file, FCC either terminates with an error or produces XML with missing or empty tags. Set missingLastFields and additionalLastFields explicitly to control this behavior.

Missing Document Name or Namespace

Omitting the Document Name or Document Namespace in the FCC configuration causes Message Mapping to fail because the XML root element does not match the ESR message type. These 2 values must exactly match the ESR data type definitions.

Wrong Character Encoding

Files using ISO-8859-1 encoding processed with a UTF-8 setting (or vice versa) produce garbled or malformed XML characters. Set the file encoding in the adapter channel configuration to match the actual encoding of the source file.

Header Line Treated as Data

Failing to set addHeaderLine=true (or the equivalent document offset) when the file contains a header row causes FCC to generate an extra XML record from the column names row, producing invalid data in the integration flow.

Use SAP PI/PO message monitoring to identify which step the error occurs in. Runtime errors in FCC show up as failed messages in the monitoring dashboard with detailed error descriptions.

Error Diagnostic Tool

Select an error symptom above to view diagnostics.

Migration of SAP PI File Channels

Background

SAP PI/PO file channels with File Content Conversion are common in long-running SAP-centric enterprise landscapes. During migration projects — including moves to SAP S/4HANA, SAP Integration Suite, or other middleware platforms — these channels must be re-created or migrated with their FCC parameter configurations intact.

Migration Challenges

File channel migration presents 3 specific challenges:

  • FCC parameter sets can be large and complex, with 20–40 parameters per channel in multi-structure scenarios
  • Manual re-entry of parameters into a new system introduces transcription errors
  • Testing migrated channels requires source files that match the original format, which may no longer be readily available

Solution

Automated migration tooling — such as the Figaf Integration Suite toolset — reads existing SAP PI/PO communication channel configurations, extracts FCC parameters, and generates equivalent channel configurations in the target system. This approach eliminates manual parameter re-entry and reduces migration time for file-heavy integration landscapes.

How it Works

The migration tool connects to the source SAP PI/PO system, reads all file adapter communication channels, identifies channels with File Content Conversion enabled, and exports the full parameter set for each channel. The export includes document name, namespace, recordset structure, field separators, field names, and all substructure-level parameters.

The tool then generates the equivalent configuration in the target environment, adapting parameter formats where the target system's API differs from the source.

Automated Migration

Automated migration handles bulk file transformation workflow scenarios where hundreds of FCC channels exist in a single SAP PI/PO system. The process runs without manual intervention for standard FCC configurations. Edge cases — such as channels using custom adapter modules for PGP decryption — are flagged for manual review.

Testing

After migration, each FCC channel requires functional testing using sample flat files. The test verifies that the XML output of the migrated channel matches the XML output of the original channel for the same input file. Discrepancies in field ordering, namespace, or encoding indicate parameter migration errors.

Modules

Channels that use adapter modules — such as those in PGP scenarios using Localejbs/PGPDecryption, AF_Modules/MessageTransformBean, and Localejbs/PGPEncryption — require the same modules to be available in the target system. Module availability in the target adapter engine must be confirmed before migration begins.

Demonstration

A typical FCC migration demonstration covers 3 scenarios:

  1. Simple CSV sender channel with a single recordset structure
  2. Multi-structure file with keyFieldName-based substructure differentiation
  3. PGP-encrypted file channel requiring adapter module migration

Each scenario validates that the migrated channel produces identical XML output to the source channel when processing the same test file.

Migration Journey Map

SAP PI/PO
📄
Simple CSV
🥞
Multi-Structure
🔒
PGP Encrypted
Target System
Click a milestone on the roadmap to view details.

Conclusion

File Content Conversion (FCC) in SAP PI/PO converts flat files into XML and XML into flat files at the adapter level, reducing development effort and removing the need for manual message mappings in basic format transformation scenarios.

FCC covers 3 core use cases: inbound CSV processing via Sender FCC, outbound XML-to-flat-file transformation via Receiver FCC, and encrypted file exchange using PGP decryption and encryption through adapter modules. Each use case requires specific parameter configurations — including fieldSeparator, recordsetStructure, keyFieldName, and documentName — to produce correct XML output.

Reliable FCC implementations follow 5 practices: validating flat files before processing, using consistent recordset structures, testing with small datasets, enabling runtime monitoring, and maintaining documentation of all parameter values. Migrating FCC channels to SAP S/4HANA or SAP Integration Suite benefits from automated tooling that extracts and re-creates parameter configurations without manual transcription.

For SAP-centric enterprises running file-based integrations across SAP ERP, CRM, SCM, and third-party systems, FCC remains one of the most efficient tools for file content migration and structured data conversion at the middleware layer.

Frequently Asked Questions

FCC supports CSV (comma-separated values), TSV (tab-separated), fixed-length flat files, and any other delimiter-separated text files. You can configure virtually any single-character delimiter using the fieldSeparator parameter. It also supports files with multiple record types differentiated by key fields.

Yes! While FCC is natively available as a Message Protocol in File and FTP adapters, you can use the MessageTransformBean (MTB) adapter module to apply content conversion with any adapter type. Add the MTB module in the Module tab of your Communication Channel and configure the FCC parameters as module parameters.

Use the RecordsetStructure parameter to define multiple structure types. For example: Header,1,Detail,*,Footer,1. Then configure a Key Field Name and set keyFieldValue for each structure so FCC can identify which lines belong to which structure. See the Multi-Record example above for a complete configuration.

Sender FCC converts flat files → XML. It reads the incoming flat file and generates an XML message based on your configuration. Receiver FCC converts XML → flat files. It takes the XML message and produces a flat file output. The parameters are similar but some are direction-specific (e.g., addHeaderLine is primarily used on the receiver side).

Standard FCC supports up to 3-4 levels of nesting. For highly complex or deeply nested XML structures, SAP recommends using Java Mapping (e.g., SAX/DOM parsers) or creating an intermediate flat structure with FCC and then using a graphical mapping to transform it into the final complex structure.

FCC cannot process encrypted files directly. You need to add a PGP decryption adapter module before the FCC module in the adapter module processing chain. The decryption module will first decrypt the file, and then the ContentConversionBean module will handle the conversion.

File content conversion in SAP is a feature of the SAP PI/PO File Adapter that transforms flat files (CSV, fixed-length text) into structured XML, or XML into flat files, at the adapter level during runtime — without requiring dedicated message mapping for the format conversion step. It is configured through FCC parameters in the sender or receiver communication channel.

Use FCC when an integration scenario requires converting a flat file to XML for inbound processing, or XML to a flat file for outbound delivery, and the transformation logic is limited to field parsing and structure mapping. FCC is the right choice for SAP NetWeaver PI/PO interfaces that receive CSV files from external systems or send flat files to legacy systems. Use Message Mapping instead when complex business transformation logic is required alongside the format change.

Yes, FCC handles large files, but test with small sample datasets first and monitor runtime performance through SAP PI's message monitoring before processing production volumes. For very large files, configure the Recordsets per Message parameter to split the file into multiple smaller messages, which reduces memory pressure on the adapter engine.