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

# Discard Draft

> Discard all draft changes and restore the workflow to its published state.

The workflow must already be published.

Discard all unpublished draft changes and restore the workflow to its last published version. The blocks and edges are recreated from the published snapshot, so the draft you see in the editor matches what new runs execute.

This is the inverse of [Publish Workflow](/api-reference/workflows/publish): publish promotes the draft to a new version; discard throws the draft away and rolls back to the current published version. The workflow must already be published — there is no published state to restore to otherwise.

<RequestExample>
  ```python Python theme={null}
  from retab import Retab

  client = Retab()

  workflow = client.workflows.discard_draft("wf_abc123xyz")

  print(workflow.published.version_id)
  ```

  ```typescript TypeScript theme={null}
  import { Retab } from "@retab/node";

  const client = new Retab({ apiKey: process.env.RETAB_API_KEY });

  const workflow = await client.workflows.discard_draft("wf_abc123xyz");

  console.log(workflow.published.versionId);
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	"log"

  	retab "github.com/retab-dev/retab/clients/go"
  )

  func main() {
  	ctx := context.Background()

  	client, err := retab.NewClient("")
  	if err != nil {
  		log.Fatal(err)
  	}

  	workflow, err := client.Workflows.DiscardDraft(ctx, "wf_abc123xyz")
  	if err != nil {
  		log.Fatal(err)
  	}

  	if workflow.Published != nil {
  		fmt.Println(workflow.Published.VersionID)
  	}
  }
  ```

  ```ruby Ruby theme={null}
  require 'retab'

  client = Retab::Client.new(api_key: ENV['RETAB_API_KEY'])

  workflow = client.workflows.discard_draft(workflow_id: 'wf_abc123xyz')

  puts workflow.published.version_id
  ```

  ```rust Rust theme={null}
  use retab::Retab;

  #[tokio::main]
  async fn main() -> Result<(), Box<dyn std::error::Error>> {
      let client = Retab::new(std::env::var("RETAB_API_KEY")?);

      let workflow = client.workflows().discard_draft("wf_abc123xyz").await?;

      if let Some(published) = &workflow.published {
          println!("{}", published.version_id.as_deref().unwrap_or(""));
      }
      Ok(())
  }
  ```

  ```php PHP theme={null}
  <?php
  require 'vendor/autoload.php';

  use Retab\Client;

  $client = new Client(apiKey: getenv('RETAB_API_KEY'));

  $result = $client->workflows()->discardDraft(
      workflowId: 'wf_abc123xyz',
  );
  print_r($result);
  ```

  ```csharp C# theme={null}
  using Retab;
  using RetabClient = Retab.Retab;

  var apiKey = Environment.GetEnvironmentVariable("RETAB_API_KEY")!;
  var client = new RetabClient(apiKey);

  var result = await client.Workflows.DiscardDraftAsync("wf_abc123xyz");
  Console.WriteLine(result);
  ```

  ```java Java theme={null}
  import com.retab.RetabClient;

  public final class Example {
    public static void main(String[] args) throws Exception {
      RetabClient client = new RetabClient(System.getenv("RETAB_API_KEY"));

      var result = client.workflows().discardDraft("wf_abc123xyz");
      System.out.println(result);
    }
  }
  ```

  ```curl cURL theme={null}
  curl -X 'POST' \
    'https://api.retab.com/v1/workflows/wf_abc123xyz/discard-draft' \
    -H 'Authorization: Bearer <your-api-key>'
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "id": "wf_abc123xyz",
    "name": "Invoice Processing",
    "description": "Extract invoice fields and route for review",
    "published": {
      "version_id": "ver_8zJfV7T9qK2mP4xN6bR1cD3eF5gH7iJ9",
      "published_at": "2026-05-01T14:30:00Z"
    },
    "created_at": "2026-04-30T17:00:00Z",
    "updated_at": "2026-05-01T14:30:00Z"
  }
  ```

  ```json 400 theme={null}
  {
    "detail": "Cannot discard draft: workflow has no published version to restore."
  }
  ```

  ```json 404 theme={null}
  {
    "detail": "Workflow not found"
  }
  ```
</ResponseExample>


## OpenAPI

````yaml POST /v1/workflows/{workflow_id}/discard-draft
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://api.retab.com
security: []
paths:
  /v1/workflows/{workflow_id}/discard-draft:
    post:
      tags:
        - Workflows
      summary: Discard Draft Workflow
      description: >-
        Discard all draft changes and restore the workflow to its published
        state.


        The workflow must already be published.
      operationId: discard_draft_workflow
      parameters:
        - in: path
          name: workflow_id
          required: true
          schema:
            type: string
            title: Workflow Id
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Workflow'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - HTTPBearer: []
components:
  schemas:
    Workflow:
      properties:
        id:
          type: string
          title: Id
          description: Unique ID for this workflow
        name:
          type: string
          title: Name
          description: The name of the workflow
          default: Untitled Workflow
        description:
          type: string
          title: Description
          description: Description of the workflow
          default: ''
        project_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Project Id
          description: >-
            Project that owns this workflow. Null only on legacy rows that
            predate the project backfill.
        published:
          anyOf:
            - $ref: '#/components/schemas/WorkflowPublished'
            - type: 'null'
          description: Published workflow metadata when a published version exists
        created_at:
          type: string
          format: date-time
          title: Created At
        updated_at:
          type: string
          format: date-time
          title: Updated At
      type: object
      required:
        - created_at
        - id
        - updated_at
      title: Workflow
      description: A workflow and its current configuration.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
          default: []
      type: object
      title: HTTPValidationError
    WorkflowPublished:
      properties:
        version_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Version Id
          description: Published content-addressed workflow version ID
        published_at:
          anyOf:
            - type: string
              format: date-time
            - type: 'null'
          title: Published At
          description: When the workflow was last published
        description:
          type: string
          title: Description
          description: >-
            Release note attached to the currently published version. Echoes the
            `description` body passed to `POST /v1/workflows/{id}/publish` so
            the caller can confirm it was stored without a separate fetch.
          default: ''
      type: object
      title: WorkflowPublished
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
        input:
          title: Input
          default: null
        ctx:
          type: object
          title: Context
          default: {}
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    HTTPBearer:
      type: http
      scheme: bearer

````