> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fga.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Transactional Writes

> Updating multiple relationship tuples in a single transaction

Using Auth0 FGA, you can update multiple [relationship tuples](https://docs.fga.dev/fga-concepts.md#what-is-a-relationship-tuple) in a single transaction.

**When to use**

Updating multiple relationship tuples can keep your system state consistent.

## Before you start

Familiarize yourself with basic [Auth0 FGA Concepts](https://docs.fga.dev/fga-concepts.md) before completing this guide.

<details>
  <summary>In the following [authorization model](https://docs.fga.dev/fga-concepts.md#what-is-an-authorization-model), there is [type](https://docs.fga.dev/fga-concepts.md#what-is-a-type) called `tweet` that can have a `reader`. There is another type called `user` that can have a `follower` and `followed_by` relationship.</summary>

  ***

  In addition:

  ### Direct access

  Creating an authorization model and a relationship tuple grants a user access to an object. To learn more, [read about Direct Access.](https://docs.fga.dev/modeling/basics/modeling-basics.md)

  ### Modeling public access

  The following example uses public access. To learn more, [read about Public Access.](https://docs.fga.dev/modeling/basics/modeling-basics.md)

  ### Auth0 FGA concepts

  * A [Type](https://docs.fga.dev/fga-concepts.md#what-is-a-type): a class of objects that have similar characteristics
  * A [User](https://docs.fga.dev/fga-concepts.md#what-is-a-user): an entity in the system that can be related to an object
  * A [Relation](https://docs.fga.dev/fga-concepts.md#what-is-a-relation): is a string defined in the type definition of an authorization model that defines the possibility of a relationship between an object of the same type as the type definition and a user in the system
  * A [Relation](https://docs.fga.dev/fga-concepts.md#what-is-a-relation): a string defined in the type definition of an authorization model that defines the possibility of a relationship between an object of the same type as the type definition and a user in the system
  * A [Relationship Tuple](https://docs.fga.dev/fga-concepts.md#what-is-a-relationship-tuple): a group stored in Auth0 FGA that consists of a user, a relation, and an object
</details>

## Step by step

### 01. Add and remove relationship tuples in the same transaction

A call to the Write API can add or delete tuples in your store. For example, the following tuple makes `tweet:1` public by making everyone a `viewer`:

Deleting the previous tuple converts this `tweet` to private:

By removing the tuple, we made the tweet visible to no-one, which may not be what we want.

<details>
  <summary>Limitations on duplicate tuples in a single request</summary>

  When using the Write API, you cannot include the same tuple (same user, relation, and object) in both the writes and deletes arrays within a single request. The API will return an error with code `cannot_allow_duplicate_tuples_in_one_request` if duplicate tuples are detected.

  For example, this request would fail:

  ```bash theme={null}
  curl -X POST "${FGA_API_URL}/stores/${FGA_STORE_ID}/write" \
    -H 'content-type: application/json' \
    --data '{
      "writes": {
        "tuple_keys": [{
          "user": "user:anne",
          "relation": "member",
          "object": "group:2"
        }]
      },
      "deletes": {
        "tuple_keys": [{
          "user": "user:anne",
          "relation": "member",
          "object": "group:2"
        }]
      }
    }'
  ```
</details>

The Write API allows you to send up to 40 unique tuples in the request. (This limit applies to the sum of both writes and deletes in that request). This means we can submit one API call that converts the `tweet` from public to visible to only the `user`'s followers.

### 02. Add multiple related relationship tuples in the same transaction

Sending multiple tuples per request can also help maintain consistency. For example, if `anne` follows `becky`, you can save the following two tuples or neither of them:

```json theme={null}
[
  // Anne is a follower of Becky
  {
    "user": "user:anne",
    "relation": "follower",
    "object": "user:becky"
  },
  // Becky is followed by Anne
  {
    "user": "user:becky",
    "relation": "followed_by",
    "object": "user:anne"
  }
]
```

> [!NOTE]
>
> In this case, the type `user` exists because users can be related to each other, so users now are a type in the system.

The Auth0 Fine-Grained Authorization (FGA) service attempts to perform all the changes sent in a single Write API call in one transaction. If it cannot complete all the changes, it rejects all of them.

## Related Sections

Check the following sections for more on how to update tuples.

[Update relationship tuples in SDK
Learn about how to update relationship tuples in SDK.](https://docs.fga.dev/integration/update-tuples.md)

[Auth0 FGA API
Details on the write API in the Auth0 FGA reference guide.](https://docs.fga.dev/api/service/relationship-tuples/write.md)