WE42 — Inbound IDoc process code assignment
WE42 maintains the customizing table that links an inbound process code to the function module (or workflow) that actually processes an incoming IDoc's application data. Partner profiles in WE20 reference a process code, not a function module directly, so a missing or mistyped entry here breaks inbound processing even when the partner profile and the IDoc itself look correct.
This page covers WE42, the transaction for maintaining inbound IDoc process codes and their function module assignments. It focuses on the layer of indirection between partner profiles and processing logic that causes most inbound IDoc failures, and how to trace a stuck IDoc back to a broken or missing process code entry.
Reviewed by an ERPClimb SAP consultant on 15 Sept 2026· 1,279 words
Purpose
WE42 is the customizing transaction for inbound process codes. A process code is a short identifier that sits between the partner profile (WE20) and the actual processing logic: the partner profile's inbound parameter for a given partner and message type names a process code, and WE42 is where that process code is bound to a function module or a workflow task. The structural fact that causes most confusion is that the process code is not the function module and not the message type — it is a separate customizing key, usually client-independent and transportable, that can exist in one system and be missing in another after a transport. When an inbound IDoc fails to post, the root cause is frequently not the interface data at all but a process code entry that was never created, was deleted, or points at a function module that no longer exists in the target system.
When it is used
WE42 is used during initial setup of any classic IDoc-based inbound interface, whenever a new message type or a custom Z function module is introduced, and during troubleshooting when inbound IDocs are stuck with a processing error that is not explained by the application data itself. It sits upstream of WE20 in the configuration chain: WE20 tells the system which process code to use for a partner and message type, WE42 tells the system what that process code actually does. A consultant reaches for WE42 rather than a Fiori app or a modern interface tool specifically because this is classic ALE/IDoc plumbing; on S/4HANA it still governs the same inbound path even where newer integration technology (CPI, APIs) handles the outer transport layer, because the IDoc still has to be dispatched to a function module once it lands.
How to use it in practice
- Start WE42 and choose display or change mode for inbound process codes.
- Search for the process code referenced by the relevant partner profile (WE20) inbound parameter, or select New Entries to create one.
- Enter the process code value, matching exactly what is used in the partner profile.
- Set the processing type: direct function module call or workflow-based processing.
- For function module processing, enter the exact function module name that will receive the IDoc control record and data segments.
- Save and route the change through a transport request, since this entry rarely exists correctly by accident in a target system.
- Cross-check the partner profile in WE20 to confirm it points at this exact process code, and test with a sample IDoc via WE19 if available.
Key data objects
- Inbound process code customizing table - stores the process code value, the processing type flag (function module versus workflow), and the function module name assigned to that code; this is a client-independent customizing table maintained through WE42's table maintenance view.
- Partner profile inbound parameter table - stores partner number, message type, and the process code that the partner's inbound configuration is set to use; this is what WE20 writes and what WE42's entry must match.
- IDoc control record - stores the message type, direction, and current status of each inbound IDoc instance; used to trace which process code should have applied to a given failed IDoc.
How to prove it in the data
Start from the failed IDoc number in the control record table, note the partner, message type, and direction. Look up the inbound partner profile entry for that partner and message type to read off the process code it is configured to use. Then check the WE42 customizing table for that exact process code value: if there is no row, the assignment was never created or was lost in a transport; if there is a row, confirm the function module name it contains still exists and has not been renamed or deleted. Finally read the IDoc's status records to see whether the error text matches 'function module not found' or a similar determination failure rather than an application posting error.
ECC vs S/4HANA
WE42 and the inbound process code concept are unchanged on S/4HANA; this remains classic ALE/IDoc customizing and there is no Fiori app that replaces it. What changes in practice is the surrounding landscape: IDocs on S/4HANA are frequently paired with cloud integration middleware for the outer transport, but once the IDoc is dispatched into the ABAP stack, the same process code determination logic in WE42 governs which function module or workflow handles it.
Common pitfalls and how to diagnose them
- Process code mismatch: the partner profile inbound parameter names a process code that does not exist in WE42, or exists with a typo (trailing space, wrong case in a custom code). Symptom is the IDoc failing at determination before any application logic runs. Fix by comparing the exact string in WE20 against the WE42 entry, not just eyeballing it — copy-paste the value rather than retyping it.
- Function module signature drift: the process code points at a real function module, but that module's interface has changed (parameter renamed, importing parameter added) without the WE42 entry being touched. This produces a runtime error or dump during processing rather than a clean IDoc status, and looks unrelated to configuration at first glance.
- Processing type confusion: a process code is set to workflow-based processing when the interface actually expects direct function module execution, or vice versa. IDocs appear to sit untouched because they are waiting in a workflow queue rather than failing outright — checking only the IDoc status without checking the process code's processing type misses this.
- Transport gaps: the WE42 entry works in development because it was created there manually, but the transport that moved the partner profile and the function module did not include the process code customizing entry. The interface then fails only in QA or production, which makes it look like an environment-specific data problem when it is a missing configuration object.
- Reflex fix that makes it worse: reprocessing the stuck IDoc repeatedly through the IDoc list without touching WE42 or WE20. Since the process code assignment itself is broken, each reprocessing attempt fails identically and adds noise to the IDoc list without diagnosing anything.
Whose problem this is
Functional consultants own the process code assignment and its mapping to the correct message type and partner. ABAP development owns the function module implementation and must be told immediately if its interface signature changes. Basis or the integration team owns the port and connection layer feeding the IDoc in. A good handover includes the process code value, the function module name, the message type, a sample failing IDoc number, and the exact status error text.
Related SAP objects
Reviewed pages this object connects to in the ERPClimb knowledge graph.
Source: ERPClimb — https://erpclimb.com/sap-tcodes/we42ERPClimb is an independent platform and is not affiliated with SAP SE. Reference pages are written and reviewed by SAP consultants for learning and troubleshooting.