--- sourceDocument: Brazil ServiceNow AI Platform Capabilities sourceDocumentLink: https://www.servicenow.com/docs/r/servicenow-platform Release : - brazil ft:locale : - en-US ft:publication_title : - Brazil ServiceNow AI Platform Capabilities ft:clusterId : - platcap bundleId : - platcap workflow : - Platform --- # General guidelines for using CMDB Identification # General guidelines for using CMDB Identification {#ariaid-title1} Release version: Brazil Updated September 10, 2026 ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 3 minutes to read Summarize ![AI sparkle icon](https://servicenow.com/docs/portal-asset/ai-sparkle-icon) Summarized using AI This content was generated using new OpenAI-powered functionality. Results are provided on an as is basis and are not guaranteed to be accurate or complete. ## Summary of General guidelines for using CMDB Identification This guide provides essential best practices for effectively using CMDB Identification within ServiceNow. It explains the types of identification rules, how to prioritize them, and offers recommendations for building efficient payloads when managing Configuration Items (CIs). Following these guidelines helps ensure accurate CI identification, optimized system performance, and streamlined data management. Show full answer Show less ## Identification Rules * **Independent identification rules:** These identify CIs solely based on their own attributes and are preferred because they are faster and less error-prone. Customers should model CIs with complete attributes that support independent identification to eliminate dependencies. * **Dependent identification rules:** These identify CIs based on their relationships with dependent CIs. They require more processing time and are more prone to errors. Use dependent rules sparingly, limiting dependency levels to one or two maximum. * **Avoid lookup identifier entries:** These can degrade performance and should be avoided unless absolutely necessary after reviewing CI class definitions. * **Optimize identifier entries:** Limit identifier entries in a rule ideally to one, as multiple entries reduce performance. Prioritize the strongest identifier entries for accuracy and efficiency. * **Class level accuracy:** Ensure identification rules are created at the appropriate class level for proper CI matching. ## Payload Construction * **Limit payload size:** Keep payloads to a maximum of 500 CIs per request to avoid performance issues. * **Eliminate duplicates:** Avoid duplicate CI entries within payloads, especially when criterion attributes like names are used for identification. * **Exclude system fields:** Do not include system-generated fields (e.g., sysdomain, sysupdatedon) in payloads as they are unnecessary and may cause errors. * **Minimal criterion attributes:** Provide only the necessary attributes required by the identification rules to identify or update CIs. * **Use sysid when available:** Including sysid in payloads enables direct CI matching, bypassing the need for other criteria and improving efficiency. This applies for both independent and dependent CIs. * **Manage dependent CIs carefully:** When inserting or updating dependent CIs, include their relationships and serialize API calls if many CIs depend on the same parent CI to prevent system performance degradation. ## Practical Impact for ServiceNow Customers By following these guidelines, ServiceNow customers can create robust CMDB identification rules that improve accuracy and minimize errors. Proper payload construction ensures faster processing and reduces system load, enabling more reliable and scalable CMDB data management. These practices help maintain data integrity and optimize overall CMDB performance during automated discovery, reconciliation, or integration processes. Review the following general guidelines for using CMDB Identification effectively. ## Identification rules {#best-practices-id-reconcile__section_dqp_3kf_d1b} An independent identification rule identifies a CI based on the CI's attributes, independently of other CIs. A dependent identification rule identifies a CI by its dependent CIs and the relationships of the identified CI with those dependent CIs. Identification with a dependent identification rule is based on the dependent CIs and the relationships and qualifiers between the identified CI and its dependent CIs. Identification then requires more time than with an independent identification rule and is prone to some identification errors. Usage of dependent rules should therefore be minimized. CI modeling determines which type of identification rules are required for proper CI identification. Create identification rules using the following order of importance: 1. Independent identification rules --- It is always preferable to create independent identification rules rather than dependent identification rules. When you model a CI, define the CI with a complete set of attributes that lend themselves to independent identification, eliminating the need to use additional CIs for identification. 2. Dependent identification rules --- If it is necessary to create dependent identification rules, then define a single level of dependency. Two is the maximum number of dependency levels that is supported. 3. Avoid creating lookup identifier entries. The use of lookup identifier entry is highly discouraged as it can reduce performance. If unavoidable, ensure to first review class definitions and consider updates that allow usage of independent identification rules. 4. Limit the number of identifier entries within an identification rule, ideally to 1. A second identifier entry can further reduce performance, as will each additional identifier entry. 5. Create strong identification rules in which the strongest identifier entries and related entries are set with the highest priority. 6. Ensure that the identification rule is at the class level that it needs to be. {#best-practices-id-reconcile__ol_w4j_y3f_d1b} ## Payload {#best-practices-id-reconcile__section_nm3_qff_g1b} Create the payload using the following order of importance: 1. Payload size --- Limit the number of CIs per payload to 500. 2. Avoid duplicate entries in the payload. Example: If an identification rule has a criterion attribute for the name field, then the following payload has duplicate items resulting in failure: var payload = { items: [{ className:'cmdb_ci_linux_server', values: { name:'Win Server 200', ram:'2048' }}, { className:'cmdb_ci_linux_server', values: { name:'Win Server 200', ram:'4096' }}] }; 3. Do not pass system data such as the following in the payload. var payload = { items: [{ className:'cmdb_ci_linux_server', values: { name:'Win Server 200', sys_domain:'global', sys_domain_path:'xyz', sys_updated_on:'2017-06-15 16:25:11', sys_mod_count:23, }}] }; 4. Provide the minimum necessary set of criterion attributes for each payload item, according to what is specified in the corresponding identification rules. 5. When matching CIs, use CIs' sysIds if available. If provided, IRE can use the sysId to directly locate a CI without requiring any criterion attributes from the identification rule. In this case, IRE does not use the sysId in the matching process. * Example: Independent CI that needs to be updated --- sysId is available. var payload = { items: [{ className:'cmdb_ci_linux_server', values: { sys_id:'194876usytrr65378098', ram:'2048', }}] }; * Example: Dependent CI that needs to be inserted. Tomcat War CI depends on Tomcat CI, and Tomcat CI depends on Linux Server CI. SysIds for the Tomcat and the Linux CIs are available. var payload = { items: [{ className:'cmdb_ci_app_server_tomcat_war', values: { name:'war1', short_description:'my description' } }, { className:'cmdb_ci_app_server_tomcat', values: { sys_id:'194876usytrr65378098' } }, { className:'cmdb_ci_linux_server', values: { sys_id:'09876tysueyt6345lakiu' } }], relations: [{ parent:1, child:0, type: 'Contains::Contained by'}, { parent:1, child:2, type:'Runs on::Runs'} ] }; * Example: Dependent CI that needs to be updated --- sysId is available. var payload = { items: [{ className:'cmdb_ci_app_server_tomcat_war', values: { sys_id:'039387euey637465sytet', short_description:'my description new' } }] }; {#best-practices-id-reconcile__ul_vnc_zff_g1b} 6. When inserting many CIs, all of which depend on the same CI, you should serialize your API calls. Otherwise, attempting to concurrently process many CIs can clog the system, significantly degrading overall system performance. {#best-practices-id-reconcile__ol_zdl_rff_g1b} **Related tasks** * [Create a CI identification rule](https://www.servicenow.com/docs/paokIuIucqW~B7gJNdcX7A "Identification rules are used to uniquely identify CIs in the CMDB, as part of Identification and Reconciliation (IRE) processes. Each CMDB class can be associated with a single identification rule.") * [Create an identification inclusion rule](https://www.servicenow.com/docs/2H_qSpoEpVolQ0darK41dA "Narrow the scope of CIs that are included in the identification process by creating an identification inclusion rule.")