Axios Interceptor Scope and Instance Isolation Limits

Direct Answer

Global interceptors do not propagate to instances created via axios.create(). Each call to axios.create() produces a brand-new AxiosInstance with its own independent interceptors.request and interceptors.response managers. There is no documented API in Axios 1.x to inherit, clone, or share an interceptor stack between instances.

Confirmed Behavior

• The default axios export is a pre-configured instance. Interceptors registered on axios.interceptors.request or axios.interceptors.response only fire for requests made through that exact instance (axios(config)).
• axios.create(config) constructs a fresh instance. Its constructor initializes this.interceptors = { request: new InterceptorManager(), response: new InterceptorManager() } — separate arrays, no reference to the global instance's handlers.
• Execution order within a single instance: request interceptors run in registration order (FIFO); response interceptors run in reverse registration order (LIFO). Errors in request interceptors skip remaining request handlers and jump to response error handlers.

Idiomatic Sharing Pattern: Factory Function

Since the library deliberately isolates instances, the standard approach is a factory that centralizes common interceptor registration:

// shared-interceptors.js
export const commonRequestInterceptors = [
  (config) => { /* auth header, logging, etc. */ return config; },
  (config) => { /* base URL normalization */ return config; }
];

export const commonResponseInterceptors = [
  (response) => { /* normalize data shape */ return response; },
  (error) => { /* global error handling */ return Promise.reject(error); }
];

// api-client-factory.js
import axios from 'axios';
import { commonRequestInterceptors, commonResponseInterceptors } from './shared-interceptors';

export function createApiClient(overrides = {}) {
  const client = axios.create({ 
    baseURL: '/api',
    timeout: 10000,
    ...overrides
  });
  
  commonRequestInterceptors.forEach(fn => client.interceptors.request.use(fn));
  commonResponseInterceptors.forEach(fn => client.interceptors.response.use(fn));
  
  return client;
}

// Usage
const publicApi = createApiClient();
const adminApi = createApiClient({ baseURL: '/admin', headers: { 'X-Admin': 'true' } });
// Add instance-specific interceptors after creation if needed
adminApi.interceptors.request.use((config) => { /* admin-only logic */ return config; });

Verification Steps

1. Create two instances: const a = axios.create(); const b = axios.create();
2. Add a request interceptor to the global axios.interceptors.request.use(() => console.log('global'))
3. Call a.get('/test') and b.get('/test') — neither logs "global".
4. Call axios.get('/test') — logs "global".
5. Inspect axios.interceptors.request.handlers vs a.interceptors.request.handlers — they are distinct arrays.

Caveats

• Mutating axios.defaults after instance creation does not affect existing instances; defaults are read at creation time.
• Third-party plugins that register on the global axios will not apply to custom instances unless the plugin explicitly accepts an instance parameter.
• Testing must spy on the specific instance's interceptors arrays, not the global one.

One Diagnostic Detail

Are you using any Axios plugins or middleware (e.g., axios-retry, axios-mock-adapter) that might expect global registration? If so, the factory pattern must explicitly pass the created instance to those plugins.