Adobe's shared responsibility model assigns merchants responsibility for their custom code and third-party integrations on Adobe Commerce cloud infrastructure, while Adobe addresses core platform security. The practical question for a buyer searching for “Magento penetration testing” is therefore which customized application, identity, API and integration boundaries a provider will actually test. A scan of the storefront home page cannot answer it.
Quick answer. Scope Magento or Adobe Commerce penetration testing around the merchant-controlled changes and the business decisions they affect: extensions, custom storefront code, Admin privileges, API and GraphQL authorization, connected services and deployment configuration. Confirm whether the estate is Magento Open Source, Adobe Commerce on cloud infrastructure or Adobe Commerce as a Cloud Service before applying platform-specific guidance. Stingrai offers web application and API penetration testing that can be scoped to those merchant-owned boundaries.
“Magento” remains a common search term, but it is not a precise architecture description. Adobe's own Security Scan Tool page distinguishes Adobe Commerce from Magento Open Source, and Adobe's REST documentation distinguishes Adobe Commerce on Cloud or on premises from Adobe Commerce as a Cloud Service. A buying brief should name the actual product, edition, deployment model, extensions, storefront technology and release state. Otherwise two vendors may quote completely different attack surfaces under the same label.
This guide is a procurement scope for a merchant-customized commerce estate. It does not claim a certification, a product-specific accreditation or a universal compliance outcome. It gives the security owner a way to ask for the evidence that matters, to separate Adobe-owned platform work from merchant-owned decisions, and to avoid paying for duplicate coverage of the same simple storefront path.
Start with the product and deployment boundary
The first RFP field should be the product in use. Magento Open Source is a distinct offering from Adobe Commerce. Adobe Commerce on cloud infrastructure is a platform-as-a-service environment covered by Adobe's published shared responsibility model. Adobe Commerce as a Cloud Service is a different service model whose available REST endpoints and identity mechanisms differ, according to Adobe's REST overview. The provider must not assume that a control described for one model exists unchanged in another.
For Adobe Commerce on cloud infrastructure, Adobe says its managed services team conducts regular penetration tests of the cloud system with the out-of-box application, while customers are responsible for testing their customized application (Adobe cloud infrastructure security). This makes an independent merchant test especially valuable when the storefront has custom code, extensions, integrations and differentiated business rules. It does not give a tester permission to probe Adobe's own underlying infrastructure or a service provider's systems without the relevant authorization.
Create a boundary diagram before scoping. Show the browser and any headless storefront, the Commerce application, custom modules, third-party extensions, Admin, REST and GraphQL interfaces, payment or tax service, order management, warehouse, identity provider, CDN and cloud environment where relevant. Mark which party owns each component and who can authorize a test. A buyer does not need to include every connected service in one engagement, but the report should state which consequences can be observed only within a downstream system that is excluded.
Record whether the production and staging configurations match for authentication, caching, store views, integrations and deployed extensions. A test against staging may be safer, yet its conclusion is limited if production uses different endpoints or privileges. A controlled production window can address a high-risk difference, provided the scope includes synthetic customers, test catalog entries, a rollback plan and a stop contact.
Make custom code and extensions the center of the assessment
Adobe's security best practices advise merchants to review extension code where possible, reduce the number of extension vendors, keep deployed components current and check for accessible development leftovers. These recommendations are useful inputs for a penetration test, but they do not replace testing of the customized application as deployed. An extension may be current and still create a merchant-specific authorization path or interact badly with custom code.
Ask the development team for an inventory of merchant-written modules and third-party extensions, with the function each one changes. Prioritize components that can read customer records, alter catalog prices, create promotions, change orders, access payment or shipping references, perform imports and exports, or expand Admin permissions. The provider should identify the custom code path to a business decision, rather than simply report that a plugin exists.
There are several valid test methods. Black-box testing shows what a user can do through the deployed interface. Authenticated grey-box testing uses representative customer and Admin accounts to reach the most important functions. Source-assisted review can help trace a custom controller, resolver or extension event to the point where identity and object ownership are checked. A quote should name which methods are included and which code repositories, packages or deployment artifacts the buyer will provide.
Treat vendor extensions as a contractual boundary as well as a technical one. The buyer usually can test the installed extension's behavior in its own authorized application; source access or probing of the extension vendor's hosted service may need separate permission. If a vendor service is out of scope, the provider can still test whether merchant-controlled code validates requests and limits privileges at the handoff. State the difference in the report.
Patch and dependency review should be evidence-led. The provider can record the deployed version, applicable Adobe advisory or vendor bulletin, and whether the merchant has applied a relevant update. It should not claim that “latest” means safe or that a patch inventory proves business logic integrity. If a version is unsupported, the risk is maintenance and exposure as described in Adobe's shared responsibility guidance; testing cannot substitute for a supported upgrade path.
Test Admin access as a business authority boundary
Commerce Admin access affects prices, promotions, content, customer support actions, integrations and user roles. The right question is not simply whether the Admin login has a second factor. The test needs to establish which administrator or support role can perform each sensitive function, whether delegated roles have only the intended scope, and whether an account can reach an action through a different interface after the UI hides it.
Adobe's Admin security documentation covers session settings, login limits and two-factor authentication. It also explains that stores using Adobe Identity Management Services authentication handle Admin identity differently from stores using native Commerce authentication. Include the actual identity mode in the scope. A provider should test the deployment's configured control, not assume a native login control is present in every setup.
Supply at least a full administrator, a limited administrator and a support or operations role if those roles exist. Mark the actions that should be denied to the limited role, such as changing an integration's access, editing a promotion rule or exporting customer records. Include a role change and account deactivation if those transitions are material. Evidence should show the resulting server-side state or denied action, not merely the absence of a menu item.
Admin activity often crosses to APIs or integrations. The same person may use a browser session and a service token. The test should determine whether identity and action attribution survive that transition. If a service integration can take a sensitive action, the report should distinguish the integration's authority from the human Admin's authority and recommend the appropriate owner for reducing it.
Separate storefront GraphQL from REST and service integrations
For Adobe Commerce and Magento Open Source PaaS implementations, Adobe's web API authentication guide describes guest, customer, administrator and integration user types, with permissions configured for API resources. That gives a concrete testing matrix: identify which routes are intentionally public, which require a customer, which require a privileged role, and which belong only to an integration. Test object ownership and function access at the API boundary, even when the browser appears to make the correct decision.
Adobe's GraphQL authorization guidance describes customer and administrator token mechanisms and session cookies for supported implementations. GraphQL storefront operations can expose carts, accounts and other data through a path different from a traditional page. The buyer should supply two synthetic customer identities and any relevant store views so the provider can verify that one customer's data and mutations stay within the intended account. An Admin token has narrow documented GraphQL use in staged-content queries; avoid writing a scope that treats every Admin function as a GraphQL operation.
REST and GraphQL are not interchangeable checkboxes. Ask the provider which operations each client actually uses and whether custom modules add resources, resolvers or permissions. OWASP API1:2023 explains why each endpoint using an object identifier needs object-level authorization. A correct customer token or a valid cart identifier does not by itself establish that the specific customer may read or change that object. Controlled cross-account negative tests should stop at the agreed proof threshold and use synthetic data.
For Adobe Commerce as a Cloud Service, do not copy a PaaS REST test list. Adobe's REST overview says the Cloud Service has a smaller REST subset, uses Adobe Identity Management Service for API authentication and places store scope in a header rather than the older URL structure. The buyer should provide the deployed API inventory and identity configuration for that model. An RFP that demands PaaS-only endpoints can make a vendor's proposal look thorough while targeting non-existent surfaces.
Follow merchant integrations and data flows
The most important flaw may sit between Commerce and another system. Promotions may come from a pricing service, orders may flow to a warehouse, customer identities may be synchronized, and support actions may call an integration with broad rights. Define the source of truth for each object and the trusted direction of each message. Then ask which party can create, modify, replay or reject a business event. The test should be concerned with authorization and integrity at the merchant's boundary, not with uncontrolled testing of the partner service.
An integration inventory should state the connecting account, its allowed functions, the data it receives, the data it can write back, and its credential owner. Adobe's PaaS API authentication guide describes integration users with configurable access. A provider can assess whether the assigned permissions match the integration's purpose and whether a compromised or misconfigured integration would reach unrelated administrative actions. The conclusion should be tied to observed configuration and controlled behavior.
Payment, tax and shipping integrations need carefully drawn limits. A merchant-side test can examine whether an order's state and amount remain consistent when a provider response returns; it should not probe the provider's own infrastructure unless that party authorizes it. The separate e-commerce checkout penetration testing guide goes deeper on payment handoff, order transitions and fulfillment. A Commerce-specific test should spend more effort on the installed extension, custom integration and platform identity decisions that a generic checkout test might not cover.
For connected systems, request evidence of the final business state. A successful HTTP response may only mean a job was queued. The report should state whether an order, inventory reservation, customer record or integration message actually changed, and which system made that change. If the provider cannot inspect a downstream system, it should mark the result as a limit rather than a pass.
Cover store views, caching and deployment configuration
Enterprise Commerce estates can serve multiple brands, regions or store views. The test scope should list which ones share code and which have different identities, prices, content or integrations. A single representative storefront may be enough for common controls, but a distinct store view can change authorization or data exposure. The provider should explain the sampling rule and record every excluded variation.
CDN and caching behavior matter when personalized data or privileged responses pass through shared delivery layers. A buyer should identify which cache or edge configuration it owns, and the provider should include controlled checks for cross-user content only where the application architecture makes that risk plausible. Test accounts and synthetic records prevent accidental exposure of real shoppers during that work. The report should distinguish a merchant-configured cache issue from an underlying platform issue it did not test.
Deployment artifacts can also expose information. Adobe's security best practices tell merchants to check for reachable logs, repository leftovers, database dumps and development files. Add that check to the authorized merchant surface. A provider should report the actual reachable item and impact, not infer exposure merely because a file name exists in a build system.
Define the release under test. Commerce updates, extensions and custom deployments can change independently. The final report should identify the tested application build and relevant installed components so the buyer can relate a finding to a release. A retest should recheck the affected behavior after a fix; a later platform patch or extension update does not automatically prove that custom authorization was corrected.
Use a component-and-owner matrix for the RFP
Give each bidder the same architecture, product model, installed customizations, role list and test boundaries. The following matrix is an editorial procurement tool drawn from Adobe's shared responsibility model, Adobe's API guidance and OWASP object authorization guidance. Delete rows that do not exist in the deployment.

Figure 1: Editorial merchant-scope matrix connecting components to a test owner and observable result. Sources: Adobe shared responsibility, Adobe web API authentication and OWASP API1:2023.
Merchant boundary | Buyer supplies | Provider demonstrates |
|---|---|---|
Custom storefront | Build and route inventory | Role and state checks in deployed code |
Extensions | Module list and function owners | Sensitive extension behavior and limits |
Admin | Full and limited roles | Allowed and denied privileged actions |
GraphQL and REST | Deployed API inventory | Customer, guest and integration authorization |
Connected systems | Data flow and permission owner | Merchant-side event and state integrity |
Deployment | Store views and configuration map | Tested build, exposed artifacts and exclusions |
The deliverable should show tested, confirmed issue, blocked and excluded states for each row. It should name whether the provider is testing the merchant application or merely reviewing Adobe documentation. A clean core-platform attestation from another party is not evidence that a merchant's custom resolver, integration role or extension behaves safely.
Choose between a scan, a penetration test and source-assisted review
Adobe's Security Scan Tool can help merchants monitor risk indicators, malware and configuration recommendations across Adobe Commerce and Magento Open Source. That is useful operational coverage. A penetration test answers a different question: whether an actor can reach an unintended customer, administrative or business outcome in this customized deployment. The scanner and the test can inform each other, but one result should not be sold as the other.
A black-box assessment may suit a narrow public storefront question. An enterprise scope with custom modules and multiple integrations usually benefits from authenticated roles and architecture context. Source-assisted review can speed investigation of custom code and show where permission checks are intended, while dynamic testing confirms behavior in the deployed environment. Ask the provider to name the people who perform each activity and the evidence returned for it.
Stingrai's human-led web application penetration testing and API testing cover authenticated roles, broken authorization and business logic, with source-assisted work where repository access is provided. Two named penetration testers are assigned to human-led engagements, reviewed by the team lead and an engagement partner. This is a web and API capability, not a claim of Adobe-specific accreditation or privileged Adobe platform access. The actual Commerce components and authorizations belong in the engagement scope.
Set safe rules for an operating store
Commerce testing can affect inventory, promotional budgets, order queues, notifications, customer records and payment references. Before testing, agree on synthetic accounts, test products, safe order states, data retention, refund or cancellation owners and a real-time contact. A provider should not use actual customer accounts or card details to prove an authorization issue. The report can show a redacted trace and final state from a controlled fixture.
Decide where testing will happen. Staging is useful for source-assisted investigation and repeatable cases if it mirrors the relevant production behavior. Production may be needed to validate an edge or integration boundary that differs from staging, but it requires a small approved window and clear stop conditions. Neither environment should be assumed representative without checking the deployment map.
State what is excluded: Adobe-owned infrastructure, the payment provider's systems, extension-vendor cloud services, denial-of-service traffic and other tenants or customer records. If a buyer later obtains written permission for a connected service, that can be a separate scope. The provider should still assess the merchant-controlled handoff and state how the exclusion limits its conclusion.
Keep findings confidential in the agreed delivery channel. Redact tokens, credentials, customer details and unnecessary payloads. A high-impact issue should be reported promptly to the buyer's contact, with enough evidence to fix it but without an uncontrolled live transaction. The test is successful when the buyer can act on a verified result safely.
Compare quotes by scope and final evidence
Two proposals with the same “Magento pentest” label can differ in tested edition, number of storefronts, Admin roles, extensions, APIs, integrations, source access and production constraints. Ask both bidders to fill in the same component-and-owner matrix. A low price may cover only unauthenticated storefront pages; a higher one may include role-based Admin and custom extension logic. The comparison is only fair when those differences are explicit.
Ask which testers will perform the work, whether authorization and business logic receive manual investigation, how suspected findings are validated, how the report separates verified outcomes from hypotheses, and whether remediation retesting is included. A strong proposal explains how it will observe final server-side state. A list of scanned URLs or a count of alerts is not an adequate substitute for that evidence.
Pricing is driven by the actual scope. More storefronts, store views, roles, installed extensions, custom API operations and connected services increase effort. The buyer can prioritize a smaller set of high-consequence boundaries, such as customer data, Admin authority and order-state integrations, then schedule other components later. Stingrai can quote the defined merchant surface through Get a Quote. Include the product and deployment model in that request so the scope is grounded in the right Adobe documentation.
Retest confirmed findings after remediation and revisit affected boundaries after a major extension change, storefront rewrite, identity migration or integration update. A one-time annual engagement provides a point-in-time record; a continuous program can follow more frequent releases. The appropriate schedule depends on the merchant's changes and assurance need, not on a generic platform label.
What a useful report should say
The report should open with the tested product, deployment model, environment, build, store views, roles and explicitly authorized components. It should list excluded Adobe, vendor and partner systems. A coverage matrix should connect each merchant-owned boundary to the method used and the evidence observed. That makes the document useful to security, engineering, operations and procurement at the same time.
For each confirmed finding, ask for the intended permission or business rule, the observed outcome, the affected custom code or configuration boundary when known, the affected role or account type, redacted evidence, impact and fix owner. A developer needs a reproducible condition; an executive needs to know whether the issue could expose customer data, grant excess Admin authority or alter an order outcome. Avoid collapsing those consequences into one generic severity sentence.
The report should separately identify uncertainties. If a third-party service could not be observed, say so. If staging differed from production, say which property differed. If a custom module was unavailable for source-assisted review, say which conclusions were based on dynamic behavior alone. A scoped conclusion is more valuable than an unsupported statement that the entire Magento estate is secure.
Retesting should refer to the same role, operation and final outcome after the fix. The buyer should be able to hand that evidence to its internal risk or audit process as support for remediation and decision-making. Stingrai's testing can produce that evidence as part of a security program; it should not be confused with a platform vendor's own core testing or with a certification.
Frequently Asked Questions
What should a Magento penetration test include?
A Magento penetration test should include the merchant's actual Adobe Commerce or Magento Open Source deployment, custom code, extensions, relevant Admin roles, storefront and API authorization, connected services and deployment configuration. The exact mix depends on the product model and the buyer's owned boundaries.
Is Adobe Commerce the same as Magento Open Source?
No. Adobe documentation treats Adobe Commerce and Magento Open Source as distinct offerings. A buyer should identify the installed product and also distinguish Adobe Commerce on cloud infrastructure from Adobe Commerce as a Cloud Service before applying API and responsibility guidance.
Does Adobe's own testing cover custom extensions?
Adobe says its managed cloud team tests the out-of-box application and that customers are responsible for penetration testing their customized application. Merchant-installed extensions and integrations therefore need an explicit merchant scope and authorization boundary.
Is Adobe's Security Scan Tool enough?
No. The scan can help monitor risk indicators, malware and configuration recommendations, while a penetration test checks whether actors can reach unintended outcomes in the customized application. Both can be useful, but their evidence answers different questions.
Should GraphQL and REST both be tested?
Test the interfaces that the deployed storefront, Admin and integrations actually use. Their available operations and authentication differ by product and deployment model, so a provider should use the buyer's API inventory rather than assume every documented route is present.
How should Admin access be tested?
Use controlled full and limited Admin roles, identify the sensitive actions assigned to each, and verify both allowed and denied outcomes in the deployed identity mode. Include API or integration paths when they can perform the same action.
Can a provider test third-party extensions and connected services?
A provider can assess installed extension behavior and merchant-controlled handoffs within the buyer's authorization. Testing an extension vendor's hosted service or another provider's infrastructure requires separate permission, and the report should state any resulting limit.
What should the final report prove?
It should identify the tested product and build, authorized components, roles and store views, observed final outcomes, confirmed findings, redacted evidence, exclusions and retest results. It should distinguish merchant customization risk from core platform testing performed by Adobe.
Related reading
References
Talk to Stingrai
Stingrai can scope a human-led web and API assessment around your merchant-owned Commerce code, roles and integrations as a one-time test or continuous program. Get a Quote with the deployed product and component map, or book a free discovery call to decide which boundaries need evidence first.


