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

# Post batch

> Deletes and adds many facts in one atomic batch. Facts are inserted and deleted in-order (ie: `insert`ed facts may be `delete`d in the same transaction). `null` can be used as a wildcard in deleted facts. Does not throw an error when the facts to delete are not found.



## OpenAPI

````yaml /reference/openapi.json post /batch
openapi: 3.1.0
info:
  title: Oso Cloud HTTP API
  version: 0.1.0
  description: >-
    <p>Oso Cloud exposes an HTTP API that you can use to make queries directly,
    without using one of the clients.</p><p>For endpoints that require
    authentication, pass your API key as an HTTP Bearer Auth payload.</p><p>For
    example, using curl: <code>curl -H &quot;Authorization: Bearer
    $OSO_AUTH&quot; https://cloud.osohq.com/api/</code></p>
servers:
  - url: https://api.osohq.com/api/
security: []
paths:
  /batch:
    post:
      tags:
        - Centralized Authorization Data
      description: >-
        Deletes and adds many facts in one atomic batch. Facts are inserted and
        deleted in-order (ie: `insert`ed facts may be `delete`d in the same
        transaction). `null` can be used as a wildcard in deleted facts. Does
        not throw an error when the facts to delete are not found.
      operationId: post_batch
      requestBody:
        content:
          application/json:
            schema:
              type: array
              items:
                $ref: '#/components/schemas/FactChangeset'
        required: true
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiResult'
        default:
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiError'
      security:
        - ApiKey: []
      x-codeSamples:
        - lang: javascript
          label: Node.js
          source: |
            import { Oso } from 'oso-cloud';

            const apiKey = process.env.OSO_CLOUD_API_KEY;
            const oso = new Oso("https://cloud.osohq.com", apiKey);

            // Batch multiple operations
            const user = { type: "User", id: "alice" };
            const org = { type: "Organization", id: "acme" };
            const repo = { type: "Repository", id: "anvils" };

            await oso.batch((tx) => {
              // Insert new facts
              tx.insert(["has_role", user, "owner", org]);
              tx.insert(["has_permission", user, "admin", repo]);
              
              // Delete old facts
              tx.delete(["has_role", user, "maintainer", repo]);
              tx.delete(["has_role", user, "member", org]);
            });
        - lang: python
          label: Python
          source: |
            import os
            from oso_cloud import Oso, Value

            oso = Oso(api_key=os.environ.get('OSO_CLOUD_API_KEY', None))

            # Batch multiple operations
            user = Value("User", "alice")
            org = Value("Organization", "acme")
            repo = Value("Repository", "anvils")

            with oso.batch() as tx:
                # Insert new facts
                tx.insert(("has_role", user, "owner", org))
                tx.insert(("has_permission", user, "admin", repo))
                
                # Delete old facts
                tx.delete(("has_role", user, "maintainer", repo))
                tx.delete(("has_role", user, "member", org))
        - lang: go
          label: Go
          source: |
            package main

            import (
                "log"
                "os"
                oso "github.com/osohq/go-oso-cloud/v2"
            )

            func main() {
                apiKey := os.Getenv("OSO_CLOUD_API_KEY")
                osoClient := oso.NewClient("https://cloud.osohq.com", apiKey)

            // Batch multiple operations
            user := oso.NewValue("User", "alice")
            org := oso.NewValue("Organization", "acme")
            repo := oso.NewValue("Repository", "anvils")

            err := osoClient.Batch(func(tx oso.BatchTransaction) {
                // Insert new facts
                tx.Insert(oso.NewFact("has_role", user, oso.String("owner"), org))
                tx.Insert(oso.NewFact("has_permission", user, oso.String("admin"), repo))
                
                // Delete old facts
                tx.Delete(oso.NewFact("has_role", user, oso.String("maintainer"), repo))
                tx.Delete(oso.NewFactPattern("has_role", user, nil, org))
            })
            if err != nil {
                log.Fatal(err)
            }
            }
        - lang: java
          label: Java
          source: |
            package com.mycompany;

            import java.io.IOException;
            import com.osohq.oso_cloud.Oso;
            import com.osohq.oso_cloud.api.ApiException;
            import com.osohq.oso_cloud.api.Value;

            public class App {
                public static void main(String[] args) {
                    String apiKey = System.getenv("OSO_CLOUD_API_KEY");
                    Oso oso = new Oso(apiKey);
                    
                    try {
                        // Batch multiple operations
                        Value user = new Value("User", "alice");
                        Value org = new Value("Organization", "acme");
                        Value repo = new Value("Repository", "anvils");
                        
                        oso.batch((tx) -> {
                            // Insert new facts
                            tx.insert("has_role", user, "owner", org);
                            tx.insert("has_permission", user, "admin", repo);
                            
                            // Delete old facts
                            tx.delete("has_role", user, "maintainer", repo);
                            tx.delete("has_role", user, "member", org);
                        });
                    } catch (IOException | ApiException e) {
                        System.err.println("Error: " + e.getMessage());
                    }
                }
            }
        - lang: ruby
          label: Ruby
          source: >
            require 'oso-cloud'


            api_key = ENV.fetch('OSO_CLOUD_API_KEY', nil)

            oso = OsoCloud::Oso.new(url: "https://cloud.osohq.com", api_key:
            api_key)


            # Batch multiple operations

            user = OsoCloud::Value.new(type: "User", id: "alice")

            org = OsoCloud::Value.new(type: "Organization", id: "acme")

            repo = OsoCloud::Value.new(type: "Repository", id: "anvils")


            oso.batch do |tx|
              # Insert new facts
              tx.tell("has_role", user, "owner", org)
              tx.tell("has_permission", user, "admin", repo)
              
              # Delete old facts
              tx.delete("has_role", user, "maintainer", repo)
              tx.delete("has_role", user, "member", org)
            end
        - lang: csharp
          label: C#
          source: >
            using OsoCloud;


            string? apiKey =
            Environment.GetEnvironmentVariable("OSO_CLOUD_API_KEY");

            var oso = new Oso("https://api.osohq.com", apiKey);


            // Batch multiple operations

            var user = new Value("User", "alice");

            var org = new Value("Organization", "acme");

            var repo = new Value("Repository", "anvils");


            await oso.Batch(tx => {
                // Insert new facts
                tx.Insert("has_role", user, "owner", org);
                tx.Insert("has_permission", user, "admin", repo);
                
                // Delete old facts
                tx.Delete("has_role", user, "maintainer", repo);
                tx.Delete("has_role", user, "member", org);
            });
components:
  schemas:
    FactChangeset:
      description: >-
        A grouped run of facts to insert or delete. Inserted facts must contain
        concrete fact args, but deleted facts may contain wildcards.
      anyOf:
        - type: object
          required:
            - inserts
          properties:
            inserts:
              type: array
              items:
                $ref: '#/components/schemas/Fact'
        - type: object
          required:
            - deletes
          properties:
            deletes:
              type: array
              items:
                $ref: '#/components/schemas/Fact'
    ApiResult:
      type: object
      required:
        - message
      properties:
        message:
          type: string
    ApiError:
      type: object
      required:
        - message
      properties:
        message:
          type: string
    Fact:
      description: 'A pattern object for matching authorization-relevant data, ie: facts.'
      type: object
      required:
        - args
        - predicate
      properties:
        predicate:
          type: string
        args:
          type: array
          items:
            $ref: '#/components/schemas/Value'
    Value:
      type: object
      properties:
        type:
          type: string
          nullable: true
        id:
          type: string
          nullable: true
  securitySchemes:
    ApiKey:
      description: Requires an API key to access.
      type: http
      scheme: bearer
      bearerFormat: Bearer e_0123_123_token0123

````