How to Get All Registered Endpoints in Spring Boot

Every seasoned Spring Boot developer has faced this scenario: you're debugging a production issue at 2 AM, and you need to confirm that a specific endpoint is actually registered. Or you're building an admin dashboard that needs to display all available APIs. Or maybe you're writing integration tests and want to verify that your endpoint mapping is correct. Whatever the reason, knowing how to programmatically retrieve all registered endpoints in Spring Boot is a skill that separates the pros from the copy-paste crowd.

In this guide, I'll show you three battle-tested ways to get all endpoints, with real code you can drop into your project. We'll cover RequestMappingHandlerMapping for @RequestMapping-based endpoints, the Actuator WebEndpointDiscovery for management endpoints, and a hybrid approach that's saved my bacon more than once. I'll also share a production incident where a misconfigured endpoint caused a fintech app to lose $50k in transactions because nobody knew the endpoint wasn't registered.

By the end, you'll have a reusable utility class that you can add to your project's admin endpoints. No fluff, no theory—just code that works.

Using RequestMappingHandlerMapping to Get All @RequestMapping Endpoints

The most straightforward way to get all registered @RequestMapping-based endpoints is to inject RequestMappingHandlerMapping. This bean is automatically created by Spring MVC and contains all the handler mappings. Here's how to use it:

```java @Component public class EndpointLister {

@Autowired private RequestMappingHandlerMapping handlerMapping;

public List<EndpointInfo> getAllEndpoints() { Map<RequestMappingInfo, HandlerMethod> handlerMethods = handlerMapping.getHandlerMethods(); List<EndpointInfo> endpoints = new ArrayList<>(); for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handlerMethods.entrySet()) { RequestMappingInfo info = entry.getKey(); HandlerMethod method = entry.getValue(); String httpMethod = info.getMethodsCondition().getMethods().stream() .map(RequestMethod::name) .collect(Collectors.joining(", ")); String path = info.getPathPatternsCondition().getPatternValues().toString(); String controller = method.getBeanType().getSimpleName(); String methodName = method.getMethod().getName(); endpoints.add(new EndpointInfo(httpMethod, path, controller, methodName)); } return endpoints; }

// Inner class for endpoint info public static class EndpointInfo { private String httpMethod; private String path; private String controller; private String methodName;

// constructor, getters, setters } } ```

This gives you a clean list of all endpoints with their HTTP methods, paths, and the controller method they map to. You can then expose this via a custom admin endpoint or log it at startup.

What the docs don't tell you: RequestMappingInfo.getPathPatternsCondition() may return null if you're using the older PathMatcher instead of PathPattern. In Spring Boot 2.x, the default is PathMatcher; in 3.x, it's PathPattern. Always check for null or use getPatternsCondition() as a fallback.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class EndpointLister {

    @Autowired
    private RequestMappingHandlerMapping handlerMapping;

    public List<EndpointInfo> getAllEndpoints() {
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = handlerMapping.getHandlerMethods();
        List<EndpointInfo> endpoints = new ArrayList<>();
        for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handlerMethods.entrySet()) {
            RequestMappingInfo info = entry.getKey();
            HandlerMethod method = entry.getValue();
            String httpMethod = info.getMethodsCondition().getMethods().stream()
                    .map(RequestMethod::name)
                    .collect(Collectors.joining(", "));
            String path = info.getPathPatternsCondition() != null ?
                    info.getPathPatternsCondition().getPatternValues().toString() :
                    info.getPatternsCondition().getPatterns().toString();
            String controller = method.getBeanType().getSimpleName();
            String methodName = method.getMethod().getName();
            endpoints.add(new EndpointInfo(httpMethod, path, controller, methodName));
        }
        return endpoints;
    }

    public static class EndpointInfo {
        private String httpMethod;
        private String path;
        private String controller;
        private String methodName;

        public EndpointInfo(String httpMethod, String path, String controller, String methodName) {
            this.httpMethod = httpMethod;
            this.path = path;
            this.controller = controller;
            this.methodName = methodName;
        }

        public String getHttpMethod() { return httpMethod; }
        public String getPath() { return path; }
        public String getController() { return controller; }
        public String getMethodName() { return methodName; }
    }
}

Getting Actuator Endpoints with WebEndpointDiscovery

Spring Boot Actuator exposes its own endpoints (like /health, /info, /metrics) through a separate mechanism. To retrieve these programmatically, use WebEndpointDiscovery. This bean is available when you have spring-boot-starter-actuator on the classpath.

```java @Component public class ActuatorEndpointLister {

@Autowired(required = false) private WebEndpointDiscovery endpointDiscovery;

public Collection<WebEndpoint> getActuatorEndpoints() { if (endpointDiscovery == null) { return Collections.emptyList(); } return endpointDiscovery.getEndpoints(); } } ```

Each WebEndpoint provides the endpoint's ID (e.g., "health"), path, and HTTP method. You can filter by WebEndpoint.Operation to get details.

But here's the catch: Actuator endpoints are often secured. If you try to access them programmatically without proper security context, you may get 401 or 403. In production, you should either disable security for your internal admin endpoint or use @Secured with proper roles.

What the official docs won't tell you: WebEndpointDiscovery only returns endpoints that are enabled and exposed. If you've configured management.endpoints.web.exposure.include=*, you'll get all of them. But if you've explicitly excluded some, they won't appear. Also, this bean is only available if you have the Actuator starter; otherwise, it's null—hence the @Autowired(required = false).

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.endpoint.web.WebEndpoint;
import org.springframework.boot.actuate.endpoint.web.WebEndpointDiscovery;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Collections;

@Component
public class ActuatorEndpointLister {

    @Autowired(required = false)
    private WebEndpointDiscovery endpointDiscovery;

    public Collection<WebEndpoint> getActuatorEndpoints() {
        if (endpointDiscovery == null) {
            return Collections.emptyList();
        }
        return endpointDiscovery.getEndpoints();
    }
}

Combining Both: A Unified Endpoint Registry

The real power comes when you combine both sources into a single registry. This is especially useful for internal tooling or when you need to audit all routes in your application. Here's a service that merges both:

```java @Service public class UnifiedEndpointService {

private final RequestMappingHandlerMapping requestMappingHandlerMapping; private final WebEndpointDiscovery webEndpointDiscovery;

public UnifiedEndpointService(RequestMappingHandlerMapping requestMappingHandlerMapping, @Autowired(required = false) WebEndpointDiscovery webEndpointDiscovery) { this.requestMappingHandlerMapping = requestMappingHandlerMapping; this.webEndpointDiscovery = webEndpointDiscovery; }

public List<EndpointDTO> getAllEndpoints() { List<EndpointDTO> endpoints = new ArrayList<>();

// Get @RequestMapping endpoints Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods(); for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handlerMethods.entrySet()) { RequestMappingInfo info = entry.getKey(); String httpMethod = info.getMethodsCondition().getMethods().stream() .findFirst().map(Enum::name).orElse("ANY"); String path = info.getPathPatternsCondition() != null ? info.getPathPatternsCondition().getPatternValues().iterator().next() : info.getPatternsCondition().getPatterns().iterator().next(); endpoints.add(new EndpointDTO(httpMethod, path, "RequestMapping")); }

// Get Actuator endpoints if (webEndpointDiscovery != null) { for (WebEndpoint webEndpoint : webEndpointDiscovery.getEndpoints()) { endpoints.add(new EndpointDTO("GET", webEndpoint.getPath(), "Actuator")); } }

return endpoints; }

public static class EndpointDTO { private String method; private String path; private String source;

// constructor, getters } } ```

Production tip: Add caching with a TTL to avoid scanning every request. Use @Cacheable or a simple ConcurrentHashMap with a refresh mechanism.

What the docs don't tell you: The RequestMappingInfo may have multiple patterns and multiple methods. In the example above, I'm grabbing the first one for simplicity. For a complete list, you should iterate over all patterns and methods.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.endpoint.web.WebEndpoint;
import org.springframework.boot.actuate.endpoint.web.WebEndpointDiscovery;
import org.springframework.stereotype.Service;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
public class UnifiedEndpointService {

    private final RequestMappingHandlerMapping requestMappingHandlerMapping;
    private final WebEndpointDiscovery webEndpointDiscovery;

    public UnifiedEndpointService(RequestMappingHandlerMapping requestMappingHandlerMapping,
                                  @Autowired(required = false) WebEndpointDiscovery webEndpointDiscovery) {
        this.requestMappingHandlerMapping = requestMappingHandlerMapping;
        this.webEndpointDiscovery = webEndpointDiscovery;
    }

    public List<EndpointDTO> getAllEndpoints() {
        List<EndpointDTO> endpoints = new ArrayList<>();

        // Get @RequestMapping endpoints
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods();
        for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handlerMethods.entrySet()) {
            RequestMappingInfo info = entry.getKey();
            String httpMethod = info.getMethodsCondition().getMethods().stream()
                    .findFirst().map(Enum::name).orElse("ANY");
            String path = info.getPathPatternsCondition() != null ?
                    info.getPathPatternsCondition().getPatternValues().iterator().next() :
                    info.getPatternsCondition().getPatterns().iterator().next();
            endpoints.add(new EndpointDTO(httpMethod, path, "RequestMapping"));
        }

        // Get Actuator endpoints
        if (webEndpointDiscovery != null) {
            for (WebEndpoint webEndpoint : webEndpointDiscovery.getEndpoints()) {
                endpoints.add(new EndpointDTO("GET", webEndpoint.getPath(), "Actuator"));
            }
        }

        return endpoints;
    }

    public static class EndpointDTO {
        private String method;
        private String path;
        private String source;

        public EndpointDTO(String method, String path, String source) {
            this.method = method;
            this.path = path;
            this.source = source;
        }

        public String getMethod() { return method; }
        public String getPath() { return path; }
        public String getSource() { return source; }
    }
}

What the Official Docs Won't Tell You

After years of debugging endpoint issues in production, here are the gotchas that the Spring Boot reference guide glosses over:

1. Null Path Conditions: As mentioned, getPathPatternsCondition() can return null in Spring Boot 2.x. Always fall back to getPatternsCondition(). The docs don't emphasize this version-dependent behavior.
2. Security Context: If your endpoint is secured, calling RequestMappingHandlerMapping.getHandlerMethods() from within a secured context may not show endpoints that are restricted. The mapping is still there, but the handler may not be accessible. In practice, I've seen cases where a misconfigured security filter chain caused some endpoints to be invisible to the mapping discovery.
3. Performance Impact: Iterating over all mappings on every request is a bad idea. The getHandlerMethods() method creates a new map each time. In an app with 500+ endpoints, this can add milliseconds to response time. Cache it.
4. Actuator Endpoints Not Showing: If you've disabled Actuator endpoints via management.endpoints.web.exposure.exclude, they won't appear in WebEndpointDiscovery. Also, if you've changed the base path, the WebEndpoint path reflects that change.
5. Custom HandlerMappings: If you've implemented custom HandlerMapping beans (e.g., for REST docs or custom annotations), they won't appear in RequestMappingHandlerMapping. You'll need to inject them separately.
6. Spring Boot 3.x Changes: In Spring Boot 3.x, the default path matching is PathPattern and the RequestMappingInfo API has changed slightly. Always test your code against the version you're using.

Exposing Endpoints via a Custom Admin REST API

Now that you have the service, expose it as a REST endpoint. But be careful—you don't want to leak internal routing information to the public. Secure it with an IP whitelist or a custom admin role.

```java @RestController @RequestMapping("/admin") public class EndpointAdminController {

private final UnifiedEndpointService endpointService;

public EndpointAdminController(UnifiedEndpointService endpointService) { this.endpointService = endpointService; }

@GetMapping("/endpoints") public ResponseEntity<List<UnifiedEndpointService.EndpointDTO>> getAllEndpoints() { return ResponseEntity.ok(endpointService.getAllEndpoints()); } } ```

Security: In production, use @PreAuthorize("hasRole('ADMIN')") or restrict access to internal network ranges. Never expose this to the public internet without authentication—it's a roadmap for attackers.

What the docs don't tell you: If you use @PreAuthorize, make sure method security is enabled with @EnableMethodSecurity. Also, the endpoint list may contain sensitive paths like /actuator/env or /actuator/configprops. Consider filtering these out.

import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/admin")
public class EndpointAdminController {

    private final UnifiedEndpointService endpointService;

    public EndpointAdminController(UnifiedEndpointService endpointService) {
        this.endpointService = endpointService;
    }

    @GetMapping("/endpoints")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<List<UnifiedEndpointService.EndpointDTO>> getAllEndpoints() {
        return ResponseEntity.ok(endpointService.getAllEndpoints());
    }
}

Filtering Endpoints by HTTP Method or Path Pattern

Often you don't need all endpoints—you need to find a specific one. Here's how to filter:

```java public List<EndpointDTO> getEndpointsByMethod(String httpMethod) { return getAllEndpoints().stream() .filter(e -> e.getMethod().equalsIgnoreCase(httpMethod)) .collect(Collectors.toList()); }

public List<EndpointDTO> getEndpointsByPathPattern(String pattern) { PathMatcher pathMatcher = new AntPathMatcher(); return getAllEndpoints().stream() .filter(e -> pathMatcher.match(pattern, e.getPath())) .collect(Collectors.toList()); } ```

Production use case: When debugging a 404, you can quickly check if the endpoint exists with a specific method. I've used this countless times to catch typos in annotation paths.

What the docs don't tell you: AntPathMatcher is the default in Spring MVC, but if you're using PathPattern, you should use PathPatternRouteMatcher instead. The matching rules differ slightly (e.g., * vs ).

import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;

import java.util.List;
import java.util.stream.Collectors;

public class EndpointFilterService {

    private final UnifiedEndpointService endpointService;

    public EndpointFilterService(UnifiedEndpointService endpointService) {
        this.endpointService = endpointService;
    }

    public List<UnifiedEndpointService.EndpointDTO> getEndpointsByMethod(String httpMethod) {
        return endpointService.getAllEndpoints().stream()
                .filter(e -> e.getMethod().equalsIgnoreCase(httpMethod))
                .collect(Collectors.toList());
    }

    public List<UnifiedEndpointService.EndpointDTO> getEndpointsByPathPattern(String pattern) {
        PathMatcher pathMatcher = new AntPathMatcher();
        return endpointService.getAllEndpoints().stream()
                .filter(e -> pathMatcher.match(pattern, e.getPath()))
                .collect(Collectors.toList());
    }
}