---
title: Flow
description: >-
  Contains functions for verifying Shopify Flow extensions.


  See the [Flow
  documentation](https://shopify.dev/docs/apps/flow/actions/endpoints) for more
  information.
api_version: v1 latest
api_name: shopify-app-react-router
source_url:
  html: >-
    https://shopify.dev/docs/api/shopify-app-react-router/latest/authenticate/flow
  md: >-
    https://shopify.dev/docs/api/shopify-app-react-router/latest/authenticate/flow.md
---

# Flow

Contains functions for verifying Shopify Flow extensions.

See the [Flow documentation](https://shopify.dev/docs/apps/flow/actions/endpoints) for more information.

## authenticate.​flow(**[request](#authenticateflow-propertydetail-request)**​)

Verifies requests coming from Shopify Flow extensions.

### Parameters

* **request**

  **Request**

  **required**

### Returns

* **Promise\<FlowContext>**

### FlowContext

* admin

  An admin context for the Flow request. Returned only if there is a session for the shop.

  ```ts
  AdminApiContext
  ```

* payload

  The payload from the Flow request.

  ```ts
  any
  ```

* session

  A session with an offline token for the shop. Returned only if there is a session for the shop.

  ```ts
  Session
  ```

### AdminApiContext

* graphql

  Methods for interacting with the Shopify Admin GraphQL API

  ```ts
  GraphQLClient<AdminOperations>
  ```

### GraphQLClient

* query

  ```ts
  Operation extends keyof Operations
  ```

* options

  ```ts
  GraphQLQueryOptions<Operation, Operations>
  ```

interface Promise\<T> { /\*\* \* Attaches callbacks for the resolution and/or rejection of the Promise. \* @param onfulfilled The callback to execute when the Promise is resolved. \* @param onrejected The callback to execute when the Promise is rejected. \* @returns A Promise for the completion of which ever callback is executed. \*/ then\<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike\<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike\<TResult2>) | undefined | null): Promise\<TResult1 | TResult2>; /\*\* \* Attaches a callback for only the rejection of the Promise. \* @param onrejected The callback to execute when the Promise is rejected. \* @returns A Promise for the completion of the callback. \*/ catch\<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike\<TResult>) | undefined | null): Promise\<T | TResult>; }, interface Promise\<T> {}, Promise: PromiseConstructor, interface Promise\<T> { readonly \[Symbol.toStringTag]: string; }, interface Promise\<T> { /\*\* \* Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The \* resolved value cannot be modified from the callback. \* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). \* @returns A Promise for the completion of the callback. \*/ finally(onfinally?: (() => void) | undefined | null): Promise\<T>; }

```ts
interface Promise<T> {
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}, interface Promise<T> {}, Promise: PromiseConstructor, interface Promise<T> {
    readonly [Symbol.toStringTag]: string;
}, interface Promise<T> {
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
}
```

### GraphQLQueryOptions

* apiVersion

  The version of the API to use for the request.

  ```ts
  ApiVersion
  ```

* headers

  Additional headers to include in the request.

  ```ts
  Record<string, any>
  ```

* signal

  An optional AbortSignal to cancel the request.

  ```ts
  AbortSignal
  ```

* tries

  The total number of times to try the request if it fails.

  ```ts
  number
  ```

* variables

  The variables to pass to the operation.

  ```ts
  ApiClientRequestOptions<Operation, Operations>["variables"]
  ```

Examples

### Examples

* #### Set a metafield on a customer after a flow call

  ##### Description

  Handle a flow action call

  ##### /app/routes/\*\*.ts

  ```typescript
  import {type ActionFunctionArgs} from 'react-router';

  import {authenticate} from '../shopify.server';

  export const action = async ({request}: ActionFunctionArgs) => {
    const {admin, payload} = await authenticate.flow(request);

    const customerId = payload.properties.customer_id;

    const response = await admin.graphql(
      `#graphql
      mutation setMetafield($customerId: ID!, $time: String!) {
        metafieldsSet(metafields: {
          ownerId: $customerId
          namespace: "my-app",
          key: "last_flow_update",
          value: $time,
          type: "string",
        }) {
          metafields {
            key
            value
          }
        }
      }
      `,
      {
        variables: {
          customerId,
          time: new Date().toISOString(),
        },
      },
    );
    const body = await response.json();

    console.log('Updated value', body.data!.metafieldsSet!.metafields![0].value);

    return new Response();
  };
  ```

* #### Flow admin context

  ##### Description

  Use the \`admin\` object in the context to interact with the Admin API.

  ##### /app/routes/flow\.tsx

  ```typescript
  import { ActionFunctionArgs } from "react-router";
  import { authenticate } from "../shopify.server";

  export async function action({ request }: ActionFunctionArgs) {
    const { admin } = await authenticate.flow(request);

    const response = await admin?.graphql(
      `#graphql
      mutation populateProduct($input: ProductInput!) {
        productCreate(input: $input) {
          product {
            id
          }
        }
      }`,
      { variables: { input: { title: "Product Name" } } }
    );

    const productData = await response.json();
    return ({ data: productData.data });
  }
  ```

* #### Flow payload

  ##### Description

  Get the request's POST payload.

  ##### /app/routes/flow\.tsx

  ```typescript
  import { ActionFunctionArgs } from "react-router";
  import { authenticate } from "../shopify.server";

  export const action = async ({ request }: ActionFunctionArgs) => {
    const { payload } = await authenticate.flow(request);
    return new Response();
  };
  ```

* #### Shopify session for the Flow request

  ##### Description

  Use the session associated with this request.

  ##### /app/routes/flow\.tsx

  ```typescript
  import { ActionFunctionArgs } from "react-router";
  import { authenticate } from "../shopify.server";

  export const action = async ({ request }: ActionFunctionArgs) => {
    const { session, admin } = await authenticate.flow(request);

    console.log(session.id)

    return new Response();
  };
  ```

## Related

[Interact with the Admin API. - Admin API context](https://shopify.dev/docs/api/shopify-app-react-router/apis/admin-api)

[Receive requests from Flow. - Flow action endpoints](https://shopify.dev/docs/apps/flow/actions/endpoints)