# ion-loading

URL: https://ionicframework.com/docs/api/loading

**Encapsulation**: [scoped](/docs/reference/glossary.md#scoped)

An overlay that can be used to indicate activity while blocking user interaction. The loading indicator appears on top of the app's content, and can be dismissed by the app to resume user interaction with the app. It includes an optional backdrop, which can be disabled by setting `showBackdrop: false` upon creation.

## Basic Usage

Once presented, the loading indicator will display indefinitely by default. Developers can manually dismiss the loading indicator after creation by calling the `dismiss()` method on the component. The `onDidDismiss` function can be called to perform an action after the loading indicator is dismissed.

Alternatively, developers can configure the loading indicator to dismiss automatically after a specific amount of time by passing the number of milliseconds to display it in the `duration` of the loading options.

### Inline (Recommended)

**JavaScript**

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading trigger="open-loading" message="Dismissing after 3 seconds..." duration="3000"></ion-loading>
```

**Angular**

`src/app/example.component.html`

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading trigger="open-loading" message="Dismissing after 3 seconds..." duration="3000"></ion-loading>
```

`src/app/example.component.ts`

```ts
import { Component } from '@angular/core';
import { IonButton, IonLoading } from '@ionic/angular';

@Component({
  selector: 'app-example',
  templateUrl: 'example.component.html',
  styleUrls: ['example.component.css'],
  imports: [IonButton, IonLoading],
})
export class ExampleComponent {}
```

**React**

```tsx
import React from 'react';
import { IonButton, IonLoading } from '@ionic/react';
function Example() {
  return (
    <>
      <IonButton id="open-loading">Show Loading</IonButton>
      <IonLoading trigger="open-loading" message="Dismissing after 3 seconds..." duration={3000} />
    </>
  );
}
export default Example;
```

**Vue**

```html
<template>
  <ion-button id="open-loading">Show Loading</ion-button>
  <ion-loading trigger="open-loading" :duration="3000" message="Dismissing after 3 seconds..."> </ion-loading>
</template>

<script setup lang="ts">
  import { IonButton, IonLoading } from '@ionic/vue';
</script>
```

### Controller

**JavaScript**

```html
<ion-button onclick="showLoading()">Show Loading</ion-button>

<script>
  var showLoading = async () => {
    const loading = await loadingController.create({
      message: 'Dismissing after 3 seconds...',
      duration: 3000,
    });

    loading.present();
  };
</script>
```

**Angular**

`src/app/example.component.html`

```html
<ion-button (click)="showLoading()">Show Loading</ion-button>
```

`src/app/example.component.ts`

```ts
import { Component } from '@angular/core';
import { IonButton, LoadingController } from '@ionic/angular';

@Component({
  selector: 'app-example',
  templateUrl: 'example.component.html',
  styleUrls: ['example.component.css'],
  imports: [IonButton],
})
export class ExampleComponent {
  constructor(private loadingCtrl: LoadingController) {}

  async showLoading() {
    const loading = await this.loadingCtrl.create({
      message: 'Dismissing after 3 seconds...',
      duration: 3000,
    });

    loading.present();
  }
}
```

**React**

```tsx
import React from 'react';
import { IonButton, useIonLoading } from '@ionic/react';
function Example() {
  /**
   * This example does not make use of the dismiss
   * method returned from `useIonLoading`, but it can
   * be used for more complex scenarios.
   */
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const [present, dismiss] = useIonLoading();
  return (
    <IonButton
      onClick={() => {
        present({
          message: 'Dismissing after 3 seconds...',
          duration: 3000,
        });
      }}
    >
      Show Loading
    </IonButton>
  );
}
export default Example;
```

**Vue**

```html
<template>
  <ion-button @click="showLoading">Show Loading</ion-button>
</template>

<script setup lang="ts">
  import { IonButton, loadingController } from '@ionic/vue';

  const showLoading = async () => {
    const loading = await loadingController.create({
      message: 'Dismissing after 3 seconds...',
      duration: 3000,
    });

    loading.present();
  };
</script>
```

## Customization

### Spinners

The spinner that is used can be customized using the `spinner` property. Refer to the [spinner property documentation](#prop-spinner) for a full list of options.

**JavaScript**

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading trigger="open-loading" message="Loading..." duration="3000" spinner="circles"></ion-loading>
```

**Angular**

`src/app/example.component.html`

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading trigger="open-loading" message="Loading..." [duration]="3000" spinner="circles"></ion-loading>
```

`src/app/example.component.ts`

```ts
import { Component } from '@angular/core';
import { IonButton, IonLoading } from '@ionic/angular';

@Component({
  selector: 'app-example',
  templateUrl: 'example.component.html',
  styleUrls: ['example.component.css'],
  imports: [IonButton, IonLoading],
})
export class ExampleComponent {}
```

**React**

```tsx
import React from 'react';
import { IonButton, useIonLoading } from '@ionic/react';
function Example() {
  return (
    <>
      <IonButton id="open-loading">Show Loading</IonButton>
      <IonLoading trigger="open-loading" message="Loading..." duration={3000} spinner="circles" />
    </>
  );
}
export default Example;
```

**Vue**

```html
<template>
  <ion-button id="open-loading">Show Loading</ion-button>
  <ion-loading trigger="open-loading" message="Loading..." duration="3000" spinner="circles"></ion-loading>
</template>

<script setup lang="ts">
  import { IonButton, IonLoading } from '@ionic/vue';
</script>
```

### Theming

Loading uses scoped encapsulation, which means it will automatically scope its CSS by appending each of the styles with an additional class at runtime. Overriding scoped selectors in CSS requires a [higher specificity](https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity) selector.

We recommend passing a custom class and using that to add custom styles to the host and inner elements.

**JavaScript**

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading class="custom-loading" trigger="open-loading" message="Loading..." duration="3000"></ion-loading>

<style>
  ion-loading.custom-loading {
    --background: #e3edff;
    --spinner-color: #1c6dff;

    color: #1c6dff;
  }
</style>
```

**Angular**

`src/app/example.component.html`

```html
<ion-button id="open-loading">Show Loading</ion-button>
<ion-loading class="custom-loading" trigger="open-loading" message="Loading..." [duration]="3000"></ion-loading>
```

`src/app/example.component.ts`

```ts
import { Component } from '@angular/core';
import { IonButton, IonLoading } from '@ionic/angular';

@Component({
  selector: 'app-example',
  templateUrl: 'example.component.html',
  styleUrls: ['example.component.css'],
  imports: [IonButton, IonLoading],
})
export class ExampleComponent {}
```

`src/global.css`

```css
ion-loading.custom-loading {
  --background: #e3edff;
  --spinner-color: #1c6dff;

  color: #1c6dff;
}
```

**React**

`src/main.tsx`

```tsx
import React from 'react';
import { IonButton, IonLoading } from '@ionic/react';

import './main.css';

function Example() {
  return (
    <>
      <IonButton id="open-loading">Show Loading</IonButton>
      <IonLoading className="custom-loading" trigger="open-loading" message="Loading" duration={3000} />
    </>
  );
}
export default Example;
```

`src/main.css`

```css
ion-loading.custom-loading {
  --background: #e3edff;
  --spinner-color: #1c6dff;

  color: #1c6dff;
}
```

**Vue**

```html
<template>
  <ion-button id="open-loading">Show Loading</ion-button>
  <ion-loading class="custom-loading" trigger="open-loading" message="Loading..." duration="3000"></ion-loading>
</template>

<script setup lang="ts">
  import { IonButton, IonLoading } from '@ionic/vue';
</script>
<style>
  ion-loading.custom-loading {
    --background: #e3edff;
    --spinner-color: #1c6dff;

    color: #1c6dff;
  }
</style>
```

**Note**

`ion-loading` is presented at the root of your application, so we recommend placing any `ion-loading` styles in a global stylesheet.

## Accessibility

Ionic automatically sets Loading's `role` to [`dialog`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/dialog_role).

If the `message` property is defined for Loading, then the `aria-labelledby` attribute will be automatically set to the message element's ID. Otherwise, `aria-labelledby` will not be set, and developers must provide an `aria-label` using the `htmlAttributes` property.

All ARIA attributes can be manually overwritten by defining custom values in the `htmlAttributes` property of Loading.

## Interfaces

### LoadingOptions

```typescript
interface LoadingOptions {
  spinner?: SpinnerTypes | null;
  message?: string | IonicSafeString;
  cssClass?: string | string[];
  showBackdrop?: boolean;
  duration?: number;
  translucent?: boolean;
  animated?: boolean;
  backdropDismiss?: boolean;
  mode?: Mode;
  keyboardClose?: boolean;
  id?: string;
  htmlAttributes?: { [key: string]: any };

  enterAnimation?: AnimationBuilder;
  leaveAnimation?: AnimationBuilder;
}
```

## Properties

### animated

**Description**: If `true`, the loading indicator will animate.

**Attribute**: `animated`

**Type**: `boolean`

**Default**: `true`

### backdropDismiss

**Description**: If `true`, the loading indicator will be dismissed when the backdrop is clicked.

**Attribute**: `backdrop-dismiss`

**Type**: `boolean`

**Default**: `false`

### cssClass

**Description**: Additional classes to apply for custom CSS. If multiple classes are provided they should be separated by spaces.

**Attribute**: `css-class`

**Type**: `string | string[] | undefined`

**Default**: `undefined`

### duration

**Description**: Number of milliseconds to wait before dismissing the loading indicator.

**Attribute**: `duration`

**Type**: `number`

**Default**: `0`

### enterAnimation

**Description**: Animation to use when the loading indicator is presented.

**Attribute**: `undefined`

**Type**: `((baseEl: any, opts?: any) => Animation) | undefined`

**Default**: `undefined`

### htmlAttributes

**Description**: Additional attributes to pass to the loader.

**Attribute**: `undefined`

**Type**: `undefined | { [key: string]: any; }`

**Default**: `undefined`

### isOpen

**Description**: If `true`, the loading indicator will open. If `false`, the loading indicator will close. Use this if you need finer grained control over presentation, otherwise just use the loadingController or the `trigger` property. Note: `isOpen` will not automatically be set back to `false` when the loading indicator dismisses. You will need to do that in your code.

**Attribute**: `is-open`

**Type**: `boolean`

**Default**: `false`

### keyboardClose

**Description**: If `true`, the keyboard will be automatically dismissed when the overlay is presented.

**Attribute**: `keyboard-close`

**Type**: `boolean`

**Default**: `true`

### leaveAnimation

**Description**: Animation to use when the loading indicator is dismissed.

**Attribute**: `undefined`

**Type**: `((baseEl: any, opts?: any) => Animation) | undefined`

**Default**: `undefined`

### message

**Description**: Optional text content to display in the loading indicator. This property accepts custom HTML as a string. Content is parsed as plaintext by default. `innerHTMLTemplatesEnabled` must be set to `true` in the Ionic config before custom HTML can be used.

**Attribute**: `message`

**Type**: `IonicSafeString | string | undefined`

**Default**: `undefined`

### mode

**Description**: The mode determines which platform styles to use. This is a [virtual property](/docs/core-concepts/fundamentals.md#virtual-properties) that is set once during initialization and will not update if you change its value after the initial render.

**Attribute**: `mode`

**Type**: `"ios" | "md"`

**Default**: `undefined`

### showBackdrop

**Description**: If `true`, a backdrop will be displayed behind the loading indicator.

**Attribute**: `show-backdrop`

**Type**: `boolean`

**Default**: `true`

### spinner

**Description**: The name of the spinner to display.

**Attribute**: `spinner`

**Type**: `"bubbles" | "circles" | "circular" | "crescent" | "dots" | "lines" | "lines-sharp" | "lines-sharp-small" | "lines-small" | null | undefined`

**Default**: `undefined`

### translucent

**Description**: If `true`, the loading indicator will be translucent. Only applies when the mode is `"ios"` and the device supports [`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).

**Attribute**: `translucent`

**Type**: `boolean`

**Default**: `false`

### trigger

**Description**: An ID corresponding to the trigger element that causes the loading indicator to open when clicked.

**Attribute**: `trigger`

**Type**: `string | undefined`

**Default**: `undefined`

## Events

| Name | Description | Bubbles |
| --- | --- | --- |
| `didDismiss` | Emitted after the loading indicator has dismissed. Shorthand for ionLoadingDidDismiss. | `true` |
| `didPresent` | Emitted after the loading indicator has presented. Shorthand for ionLoadingWillDismiss. | `true` |
| `ionLoadingDidDismiss` | Emitted after the loading has dismissed. | `true` |
| `ionLoadingDidPresent` | Emitted after the loading has presented. | `true` |
| `ionLoadingWillDismiss` | Emitted before the loading has dismissed. | `true` |
| `ionLoadingWillPresent` | Emitted before the loading has presented. | `true` |
| `willDismiss` | Emitted before the loading indicator has dismissed. Shorthand for ionLoadingWillDismiss. | `true` |
| `willPresent` | Emitted before the loading indicator has presented. Shorthand for ionLoadingWillPresent. | `true` |

## Methods

### dismiss

**Description**: Dismiss the loading overlay after it has been presented. This is a no-op if the overlay has not been presented yet. If you want to remove an overlay from the DOM that was never presented, use the [remove](https://developer.mozilla.org/en-US/docs/Web/API/Element/remove) method.

**Signature**: `dismiss(data?: any, role?: string) => Promise<boolean>`

**Parameters**: **data**: Any data to emit in the dismiss events. **role**: The role of the element that is dismissing the loading. This can be useful in a button handler for determining which button was clicked to dismiss the loading. Some examples include: `"cancel"`, `"destructive"`, `"selected"`, and `"backdrop"`.

### onDidDismiss

**Description**: Returns a promise that resolves when the loading did dismiss.

**Signature**: `onDidDismiss<T = any>() => Promise<OverlayEventDetail<T>>`

### onWillDismiss

**Description**: Returns a promise that resolves when the loading will dismiss.

**Signature**: `onWillDismiss<T = any>() => Promise<OverlayEventDetail<T>>`

### present

**Description**: Present the loading overlay after it has been created.

**Signature**: `present() => Promise<void>`

## CSS Shadow Parts

No CSS shadow parts available for this component.

## CSS Custom Properties

**iOS**

| Name | Description |
| --- | --- |
| `--backdrop-opacity` | Opacity of the backdrop |
| `--background` | Background of the loading dialog |
| `--height` | Height of the loading dialog |
| `--max-height` | Maximum height of the loading dialog |
| `--max-width` | Maximum width of the loading dialog |
| `--min-height` | Minimum height of the loading dialog |
| `--min-width` | Minimum width of the loading dialog |
| `--spinner-color` | Color of the loading spinner |
| `--width` | Width of the loading dialog |

**MD**

| Name | Description |
| --- | --- |
| `--backdrop-opacity` | Opacity of the backdrop |
| `--background` | Background of the loading dialog |
| `--height` | Height of the loading dialog |
| `--max-height` | Maximum height of the loading dialog |
| `--max-width` | Maximum width of the loading dialog |
| `--min-height` | Minimum height of the loading dialog |
| `--min-width` | Minimum width of the loading dialog |
| `--spinner-color` | Color of the loading spinner |
| `--width` | Width of the loading dialog |

## Slots

No slots available for this component.