diff --git a/docs/api_reference.md b/docs/api_reference.md
index cc5fa610..dcfa0d5c 100644
--- a/docs/api_reference.md
+++ b/docs/api_reference.md
@@ -109,103 +109,103 @@ Parameters are listed with their defaults as defined in the constructors.
 | `file_object` | `None` | An open binary file object. |
 | `file_name` | `None` | Override the file name. |
 
-### `FileInput`
+### `DetokenizeRequest`
 
-`skyflow.vault.detect` — wrapper for a file passed to `DeidentifyFileRequest`. Provide one of:
+`skyflow.vault.tokens` — passed to `vault().detokenize()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `file` | `None` | An open binary file (`BufferedReader`). |
-| `file_path` | `None` | Path to a file. |
+| `data` | _(required)_ | List of `{token, redaction_type}` dicts to detokenize. See [`RedactionType`](#redactiontype). |
+| `continue_on_error` | `False` | Continue despite per-token errors. |
 
-### `DeidentifyTextRequest`
+### `TokenizeRequest`
 
-`skyflow.vault.detect` — passed to `detect().deidentify_text()`.
+`skyflow.vault.tokens` — passed to `vault().tokenize()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `text` | _(required)_ | Text to de-identify. |
-| `entities` | `None` | Entity types to detect. See `DetectEntities`. |
-| `allow_regex_list` | `None` | Regex patterns to always treat as detectable. |
-| `restrict_regex_list` | `None` | Regex patterns to exclude from detection. |
-| `token_format` | `None` | `TokenFormat` controlling token types per entity. |
-| `transformations` | `None` | `Transformations` (e.g. date shifting). |
+| `values` | _(required)_ | List of `{value, column_group}` dicts to tokenize. |
 
-### `DeidentifyFileRequest`
+### `DeleteRequest`
 
-`skyflow.vault.detect` — passed to `detect().deidentify_file()`.
+`skyflow.vault.data` — passed to `vault().delete()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `file` | `None` | A `FileInput`. |
-| `entities` | `None` | Entity types to detect. |
-| `allow_regex_list` | `None` | Regex patterns to always treat as detectable. |
-| `restrict_regex_list` | `None` | Regex patterns to exclude. |
-| `token_format` | `None` | `TokenFormat` per entity. |
-| `transformations` | `None` | `Transformations` (not supported for Documents/Images/PDFs). |
-| `output_processed_image` | `None` | Include the processed image in output. |
-| `output_ocr_text` | `None` | Include OCR text in the response. |
-| `masking_method` | `None` | See [`MaskingMethod`](#maskingmethod). |
-| `pixel_density` | `None` | Pixel density for PDF processing. |
-| `max_resolution` | `None` | Max resolution for PDF processing. |
-| `output_processed_audio` | `None` | Include processed audio. |
-| `output_transcription` | `None` | See [`DetectOutputTranscriptions`](#detectoutputtranscriptions). |
-| `bleep` | `None` | Audio bleep config. See [`Bleep`](#bleep). |
-| `output_directory` | `None` | Directory to write the processed file. |
-| `wait_time` | `None` | Max seconds to wait (≤ 64). |
+| `table` | _(required)_ | Target table name. |
+| `ids` | _(required)_ | List of Skyflow IDs to delete. |
 
-### `DetokenizeRequest`
+### `QueryRequest`
 
-`skyflow.vault.tokens` — passed to `vault().detokenize()`.
+`skyflow.vault.data` — passed to `vault().query()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `data` | _(required)_ | List of `{token, redaction_type}` dicts to detokenize. See [`RedactionType`](#redactiontype). |
-| `continue_on_error` | `False` | Continue despite per-token errors. |
+| `query` | _(required)_ | The SQL query string to execute. |
 
-### `TokenizeRequest`
+### `DeidentifyStringRequest`
 
-`skyflow.vault.tokens` — passed to `vault().tokenize()`.
+`skyflow.vault.detect` — passed to `detect().deidentify_string()`. Set `configuration_id` or `configuration`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `values` | _(required)_ | List of `{value, column_group}` dicts to tokenize. |
+| `text` | _(required)_ | Text to de-identify. Must be non-empty. |
+| `configuration_id` | `None` | ID of an existing Detect configuration. |
+| `configuration` | `None` | Inline configuration. See [`DetectConfiguration`](#detectconfiguration). |
 
-### `DeleteRequest`
+### `DeidentifyFileRequest`
 
-`skyflow.vault.data` — passed to `vault().delete()`.
+`skyflow.vault.detect` — passed to `detect().deidentify_file()`. Supply the file with `file_path`, `file`, or `data_source` and `value`. A local `file` or `file_path` can't be combined with `value`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `table` | _(required)_ | Target table name. |
-| `ids` | _(required)_ | List of Skyflow IDs to delete. |
+| `file_path` | `None` | Path to a local file. The SDK base64-encodes it. |
+| `file` | `None` | A local file opened in binary mode. The SDK base64-encodes it. If you also set `file_path`, the SDK reads `file_path`. |
+| `data_source` | `None` | Source of `value`. See [`DataSourceType`](#datasourcetype). Required when you don't pass `file` or `file_path`. |
+| `value` | `None` | Base64 content, Skyflow ID, or presigned URL, matching `data_source`. |
+| `data_format` | `None` | Format of the input file. See [`FileDataFormat`](#filedataformat). Inferred from the file extension for a local file when not set. |
+| `configuration_id` | `None` | ID of an existing Detect configuration. |
+| `configuration` | `None` | Inline configuration. See [`DetectConfiguration`](#detectconfiguration). |
+| `poll_options` | `None` | Poll the run until it finishes or the polling limits are reached. See [`PollOptions`](#polloptions). Without it, the call returns after submitting the run. |
+| `output_directory` | `None` | Directory for processed outputs of a local file. Requires `poll_options`. |
 
-### `QueryRequest`
+### `GetRunRequest`
 
-`skyflow.vault.data` — passed to `vault().query()`.
+`skyflow.vault.detect` — passed to `detect().get_run()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `query` | _(required)_ | The SQL query string to execute. |
+| `run_id` | _(required)_ | The `run_id` returned by `deidentify_file`. Must be non-empty. |
+
+### `ReidentifyStringRequest`
+
+`skyflow.vault.detect` — passed to `detect().reidentify_string()`.
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `text` | _(required)_ | De-identified text to re-identify. Must be non-empty. |
+| `redaction_level` | `None` | List of [`RedactionLevel`](#redactionlevel) objects that set how each entity type displays. |
 
-### `ReidentifyTextRequest`
+### `ReidentifyFileRequest`
 
-`skyflow.vault.detect` — passed to `detect().reidentify_text()`.
+`skyflow.vault.detect` — passed to `detect().reidentify_file()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `text` | _(required)_ | The redacted/de-identified text to re-identify. |
-| `redacted_entities` | `None` | Entity types to keep redacted. See `DetectEntities`. |
-| `masked_entities` | `None` | Entity types to mask. |
-| `plain_text_entities` | `None` | Entity types to reveal as plain text. |
+| `data_source` | `None` | Source of `value`. See [`DataSourceType`](#datasourcetype). Required. |
+| `value` | `None` | Base64 content, Skyflow ID, or presigned URL, matching `data_source`. Required. |
+| `data_format` | `None` | Format of the input file: `txt`, `csv`, `json`, `xlsx`, `docx`, `pptx`, `xml`, or `jsonl`. See [`FileDataFormat`](#filedataformat). |
+| `redaction_level` | `None` | List of [`RedactionLevel`](#redactionlevel) objects that set how each entity type displays. |
 
-### `GetDetectRunRequest`
+### `CheckGuardrailsRequest`
 
-`skyflow.vault.detect` — passed to `detect().get_detect_run()`.
+`skyflow.vault.detect` — passed to `detect().check_guardrails()`.
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `run_id` | _(required)_ | The `run_id` returned by a prior `deidentify_file` call. |
+| `text` | _(required)_ | Text to check. Must be non-empty. |
+| `check_toxicity` | `None` | Set to `True` to check the text for toxicity. |
+| `deny_topics` | `None` | List of topics to deny. |
 
 ### `InvokeConnectionRequest`
 
@@ -225,7 +225,7 @@ Parameters are listed with their defaults as defined in the constructors.
 
 Every vault, token, connection, and Detect operation returns a typed response object. Each attribute below lists its type and meaning. Types use `| None` to mark attributes that may be absent.
 
-> **The `errors` attribute** is common to most responses. It is `list[dict] | None` and is populated only on partial failure (for example when `continue_on_error=True`); it is `None` when there are no errors. Each error dict contains `request_index`, `request_id`, `error`, and `http_code`. The per-class tables below describe only the operation-specific attributes and refer back to this note for `errors`.
+> **The `errors` attribute** is common to the vault, token, and connection responses. It is `list[dict] | None` and is populated only on partial failure (for example when `continue_on_error=True`); it is `None` when there are no errors. Each error dict contains `request_index`, `request_id`, `error`, and `http_code`. The per-class tables below describe only the operation-specific attributes and refer back to this note for `errors`. Detect responses don't have an `errors` attribute; a failed Detect call raises `SkyflowError`.
 
 ```python
 response = skyflow_client.vault('<VAULT_ID>').insert(insert_request)
@@ -315,47 +315,63 @@ print(response.errors)           # None unless there was a partial failure
 | `metadata` | `dict` | Response metadata (for example `request_id`). Defaults to `{}`. |
 | `errors` | `list[dict] \| None` | See the note above. |
 
-### `DeidentifyTextResponse`
+### `DeidentifyStringResponse`
 
-`skyflow.vault.detect` — returned by `detect().deidentify_text()`.
+`skyflow.vault.detect` — returned by `detect().deidentify_string()`.
 
 | Attribute | Type | Description |
 |-----------|------|-------------|
 | `processed_text` | `str` | The de-identified text. |
-| `entities` | `list[EntityInfo]` | Detected entities. See [`EntityInfo`](#entityinfo). |
-| `word_count` | `int` | Word count of the input text. |
-| `char_count` | `int` | Character count of the input text. |
-| `errors` | `list \| None` | See the note above. |
+| `entities` | `list[DetectedEntity]` | Detected entities. Defaults to `[]`. See [`DetectedEntity`](#detectedentity). |
+| `metrics` | `Metrics \| None` | Processing metrics. See [`Metrics`](#metrics). |
 
-### `ReidentifyTextResponse`
+### `DeidentifyFileResponse`
 
-`skyflow.vault.detect` — returned by `detect().reidentify_text()`.
+`skyflow.vault.detect` — returned by `detect().deidentify_file()`. Without `poll_options`, only `run_id` is set, `status` is `None`, and `output` is `[]`.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `run_id` | `str \| None` | Run identifier. Pass it to `get_run`. |
+| `status` | `DetectRunStatus \| None` | Status of the run. See [`DetectRunStatus`](#detectrunstatus). |
+| `output_type` | `DataSourceType \| None` | Form of the outputs. See [`DataSourceType`](#datasourcetype). |
+| `output` | `list[FileOutput]` | Processed outputs. See [`FileOutput`](#fileoutput). |
+| `metrics` | `Metrics \| None` | Processing metrics. See [`Metrics`](#metrics). |
+| `message` | `str \| None` | Message returned for the run. |
+
+### `GetRunResponse`
+
+`skyflow.vault.detect` — returned by `detect().get_run()`. Has the same attributes as [`DeidentifyFileResponse`](#deidentifyfileresponse). A status the SDK doesn't recognize maps to `DetectRunStatus.UNKNOWN`.
+
+### `ReidentifyStringResponse`
+
+`skyflow.vault.detect` — returned by `detect().reidentify_string()`.
 
 | Attribute | Type | Description |
 |-----------|------|-------------|
 | `processed_text` | `str` | The re-identified text. |
-| `errors` | `list \| None` | See the note above. |
+| `metrics` | `Metrics \| None` | Processing metrics. See [`Metrics`](#metrics). |
 
-### `DeidentifyFileResponse`
+### `ReidentifyFileResponse`
+
+`skyflow.vault.detect` — returned by `detect().reidentify_file()`.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `status` | `DetectRunStatus` | Status of the operation. See [`DetectRunStatus`](#detectrunstatus). |
+| `output_type` | `DataSourceType \| None` | Form of the outputs. See [`DataSourceType`](#datasourcetype). |
+| `output` | `list[FileOutput]` | Re-identified outputs. See [`FileOutput`](#fileoutput). |
+| `metrics` | `Metrics \| None` | Processing metrics. See [`Metrics`](#metrics). |
 
-`skyflow.vault.detect` — returned by `detect().deidentify_file()` and `detect().get_detect_run()`. All non-error attributes are optional (default `None`) and are populated based on the file type and processing status. If processing exceeds `wait_time`, only `run_id` and `status` are set; poll with `get_detect_run`.
+### `CheckGuardrailsResponse`
+
+`skyflow.vault.detect` — returned by `detect().check_guardrails()`.
 
 | Attribute | Type | Description |
 |-----------|------|-------------|
-| `file_base64` | `str \| None` | The processed file as a base64 string. |
-| `file` | `File \| None` | The processed file wrapper. See [`File`](#file). |
-| `type` | `str \| None` | MIME type of the processed file. |
-| `extension` | `str \| None` | File extension of the processed file. |
-| `word_count` | `int \| None` | Word count (text-bearing files). |
-| `char_count` | `int \| None` | Character count (text-bearing files). |
-| `size_in_kb` | `float \| None` | Size of the processed file in KB. |
-| `duration_in_seconds` | `float \| None` | Duration in seconds (audio files). |
-| `page_count` | `int \| None` | Page count (PDF/document files). |
-| `slide_count` | `int \| None` | Slide count (presentation files). |
-| `entities` | `list[EntityInfo]` | Detected entities. Defaults to `[]`. See [`EntityInfo`](#entityinfo). |
-| `run_id` | `str \| None` | Run identifier; pass to `get_detect_run` to poll for results. |
-| `status` | `str \| None` | Processing status of the run. |
-| `errors` | `list \| None` | See the note above. |
+| `text` | `str` | The text that was checked. |
+| `validation` | `GuardrailsValidation` | Whether the text passed. See [`GuardrailsValidation`](#guardrailsvalidation). |
+| `toxic` | `bool \| None` | Whether the text is toxic. |
+| `denied_topic` | `bool \| None` | Whether the text includes a denied topic. |
 
 ---
 
@@ -384,7 +400,7 @@ Vault hostnames per environment (used internally; exported for reference).
 
 ### `RedactionType`
 
-How retrieved data is displayed. Values: `PLAIN_TEXT`, `MASKED`, `DEFAULT`, `REDACTED`. See [Redaction Types](../README.md#redaction-types).
+How retrieved or re-identified data is displayed. Used by `GetRequest`, `DetokenizeRequest`, and [`RedactionLevel`](#redactionlevel). Values: `PLAIN_TEXT`, `MASKED`, `DEFAULT`, `REDACTED`. See [Redaction Types](../skyvault/README.md#redaction-types).
 
 ### `TokenMode`
 
@@ -396,10 +412,6 @@ Bring-your-own-token mode for `InsertRequest`/`UpdateRequest`.
 | `ENABLE` | Accept caller-supplied tokens. |
 | `ENABLE_STRICT` | Accept caller-supplied tokens with strict validation. |
 
-### `TokenType`
-
-Token format for Detect. Values: `VAULT_TOKEN` (`vault_token`), `ENTITY_UNIQUE_COUNTER` (`entity_unq_counter`), `ENTITY_ONLY` (`entity_only`).
-
 ### `ContentType`
 
 Content type for connection requests. Values: `JSON`, `PLAINTEXT`, `XML`, `URLENCODED`, `FORMDATA`, `HTML`.
@@ -410,67 +422,243 @@ HTTP method for connections. Values: `GET`, `POST`, `PUT`, `DELETE`, `NONE`.
 
 > Note: `PATCH` is **not** a member of this enum.
 
-### `MaskingMethod`
+### `EntityType`
+
+Entity types for Detect, used in [`Entity`](#entity) and [`RedactionLevel`](#redactionlevel). Examples: `NAME`, `EMAIL_ADDRESS`, `SSN`, `CREDIT_CARD`, `DOB`, `PHONE_NUMBER`, `ALL`.
+
+### `DeidentificationType`
+
+How Detect de-identifies an entity. Values: `VAULT_TOKEN`, `ENTITY_UNIQUE_COUNTER`, `ENTITY_ONLY`, `MASK`, `UNKNOWN`. `VAULT_TOKEN` supports only `txt`, `json`, `csv`, `xml`, `jsonl`, `docx`, `xlsx`, and `pptx` files.
+
+### `ReturnEntitiesType`
+
+Which detected entities a de-identify response includes.
+
+| Member | Meaning |
+|--------|---------|
+| `EXCLUDE_SENSITIVE_DATA` | Each entity's token, type, location, and scores, without the original value. |
+| `ALL` | Each entity's metadata and the original value. |
+| `NONE` | No entities. |
+
+### `DataSourceType`
+
+Source of a file `value`, and form of file outputs. Values: `BASE64`, `SKYFLOW_ID`, `PRESIGNED_URL`.
+
+### `FileDataFormat`
+
+File formats for Detect. Values: `BMP`, `CSV`, `DCM`, `DOC`, `DOCX`, `GIF`, `JPEG`, `JPG`, `JSON`, `JSONL`, `MP3`, `PDF`, `PNG`, `PPT`, `PPTX`, `TIF`, `TIFF`, `TXT`, `WAV`, `XLS`, `XLSX`, `XML`, `ZIP`. Each value is the lowercase extension, for example `FileDataFormat.PDF.value` is `pdf`.
+
+### `DetectRunStatus`
+
+Status of a Detect file run. Values: `QUEUED`, `IN_PROGRESS`, `SUCCESS`, `FAILED`, `UNKNOWN`. Polling stops at `SUCCESS`, `FAILED`, or `UNKNOWN`.
 
-Image masking method for Detect file de-identification. Values: `BLACKBOX` (`blackbox`), `BLUR` (`blur`).
+### `ObjectEntityType`
 
-### `DetectOutputTranscriptions`
+Object types for Detect to find. Values: `FACE`, `LICENSE_PLATE`, `LOGO`, `SIGNATURE`, `ALL`, `NONE`.
 
-Audio transcription output type for Detect. Values: `DIARIZED_TRANSCRIPTION`, `MEDICAL_DIARIZED_TRANSCRIPTION`, `MEDICAL_TRANSCRIPTION`, `TRANSCRIPTION`, `PLAINTEXT_TRANSCRIPTION`.
+### `ObjectDeidentificationType`
 
-### `DetectEntities`
+How Detect handles a detected object. Values: `REDACT`, `UNREDACT`, `UNKNOWN`.
 
-Entity types Detect can identify (e.g. `SSN`, `CREDIT_CARD`, `NAME`, `DOB`). Import from `skyflow.utils.enums`.
+### `OutputTranscriptionType`
+
+Audio transcription to include in the output. Values: `TRANSCRIPTION`, `MEDICAL_TRANSCRIPTION`, `DIARIZED_TRANSCRIPTION`, `MEDICAL_DIARIZED_TRANSCRIPTION`, `NONE`.
+
+### `PdfProcessingMode`
+
+How Detect processes a PDF. Values: `TEXT_LAYER` (process the PDF's text layer), `OCR` (process each page as an image, for scanned or image-based PDFs), `NONE`.
+
+### `MaskingMethod`
+
+How Detect masks entities in an image. Values: `BLUR`, `BLACKBOX`, `NONE`.
+
+### `GuardrailsValidation`
+
+Result of a guardrails check. Values: `PASSED`, `FAILED`, `UNKNOWN`.
 
 ---
 
 ## Detect helper classes
 
-Importable from `skyflow.vault.detect`.
+Importable from `skyflow.vault.detect`. Every parameter defaults to `None`.
 
-### `EntityInfo`
+### `DetectConfiguration`
 
-A detected entity, returned inside `DeidentifyTextResponse.entities`.
+An inline Detect configuration, passed as `configuration` to `deidentify_string` or `deidentify_file`. The SDK adds the vault ID from your vault configuration.
 
-| Attribute | Type | Description |
+| Parameter | Type | Description |
 |-----------|------|-------------|
-| `token` | `str` | The token replacing the entity. |
-| `value` | `str` | The original entity value. |
-| `text_index` | `TextIndex` | Position in the input text. |
-| `processed_index` | `TextIndex` | Position in the processed text. |
-| `entity` | `str` | Entity type. |
-| `scores` | `Dict[str, float]` | Confidence scores. |
+| `name` | `str` | Name of the configuration. |
+| `description` | `str` | Description of the configuration. |
+| `detect` | `Detect` | Entity detection and de-identification settings. See [`Detect`](#detect). |
+| `file_mapping` | `list[FileMapping]` | Source and destination locations for files. See [`FileMapping`](#filemapping). |
+| `media` | `Media` | Options for audio, documents, and images. See [`Media`](#media). |
 
-### `TextIndex`
+### `Detect`
 
-| Attribute | Type | Description |
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `entities` | `list[Entity]` | Entity types to detect and how to de-identify each. See [`Entity`](#entity). |
+| `object_entities` | `list[ObjectEntity]` | Object types to detect and how to handle each. See [`ObjectEntity`](#objectentity). |
+| `restrict` | `list[str]` | Patterns for entities to replace with `[RESTRICTED]`. A pattern must match the entity's full value. |
+| `skip` | `list[str]` | Patterns for entities to leave in plain text. A pattern can match the full value or a substring. `skip` takes precedence over `restrict`. |
+| `custom_types` | `list[CustomType]` | Custom entity types. See [`CustomType`](#customtype). |
+| `return_entities` | `ReturnEntitiesType` | Which detected entities the response includes. See [`ReturnEntitiesType`](#returnentitiestype). |
+
+### `Entity`
+
+| Parameter | Type | Description |
 |-----------|------|-------------|
-| `start` | `int` | Start offset. |
-| `end` | `int` | End offset. |
+| `entity_type` | `EntityType` | Entity type to detect. See [`EntityType`](#entitytype). |
+| `deidentification_type` | `DeidentificationType` | How to de-identify the entity. See [`DeidentificationType`](#deidentificationtype). |
+| `destination` | `str` | Vault column that stores detected values, in `table.column` format (for example, `persons.name`). |
+| `transformation` | `Transformation` | Transformation to apply. See [`Transformation`](#transformation). |
+
+### `Transformation`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `shift_dates` | `ShiftDates` | Shift dates within a range of days. See [`ShiftDates`](#shiftdates). |
+
+### `ShiftDates`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `min_days` | `int` | Minimum number of days to shift dates. |
+| `max_days` | `int` | Maximum number of days to shift dates. |
+
+### `ObjectEntity`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `entity_type` | `ObjectEntityType` | Object to detect. See [`ObjectEntityType`](#objectentitytype). |
+| `deidentification_type` | `ObjectDeidentificationType` | How to handle the object. See [`ObjectDeidentificationType`](#objectdeidentificationtype). |
+
+### `CustomType`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `label` | `str` | Label of the custom type, used as its token prefix. |
+| `match` | `list[str]` | Regular expressions. A detected entity that a pattern matches in full is replaced with `[<label>]`. |
+
+### `FileMapping`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `source` | `str` | Location of the source file. |
+| `destination` | `str` | Location of the target file. |
+| `output_file_name_suffix` | `str` | Suffix for the output file name. For example, `_deidentified` turns `invoice.pdf` into `invoice_deidentified.pdf`. |
+| `entities_destination` | `str` | Column for the entities output, in `table.column` format, in the same table as `source`. |
+| `object_entities_destination` | `str` | Column for the object entities output, in `table.column` format, in the same table as `source`. |
+
+### `Media`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `audio` | `Audio` | Audio options. See [`Audio`](#audio). |
+| `document` | `Document` | Document options. See [`Document`](#document). |
+| `image` | `Image` | Image options. See [`Image`](#image). |
+
+### `Audio`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `output_processed_audio` | `bool` | Include the processed audio in the output. Can't be combined with `output_transcription`. |
+| `output_transcription` | `OutputTranscriptionType` | Transcription to include. See [`OutputTranscriptionType`](#outputtranscriptiontype). |
+| `bleep` | `Bleep` | Bleep sound that masks entities. See [`Bleep`](#bleep). |
 
 ### `Bleep`
 
-Audio bleep configuration for `DeidentifyFileRequest`.
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `start_padding` | `float` | Padding before the bleep, in seconds (0–20). |
+| `stop_padding` | `float` | Padding after the bleep, in seconds (0–20). |
+| `frequency` | `int` | Frequency of the bleep, in Hz. |
+| `gain` | `int` | Relative loudness. Positive values are louder; negative values are quieter. |
+
+### `Document`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pdf` | `Pdf` | PDF options. See [`Pdf`](#pdf). |
+
+### `Pdf`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `processing_mode` | `PdfProcessingMode` | See [`PdfProcessingMode`](#pdfprocessingmode). |
+| `density` | `int` | Pixel density. Applies only to `OCR` mode. |
+| `max_resolution` | `int` | Maximum resolution. Applies only to `OCR` mode. |
+
+### `Image`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `output_processed_image` | `bool` | Include the processed image in the output. |
+| `output_ocr_text` | `bool` | Include text detected by OCR in the output. |
+| `masking_method` | `MaskingMethod` | See [`MaskingMethod`](#maskingmethod). |
+
+### `PollOptions`
+
+Polling limits for `deidentify_file`. The SDK waits 1, 2, 4, 8, 16, and then 32 seconds between attempts.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `wait_time` | `int` | Maximum total wait, in seconds. Default `60`, range 1–300. |
+| `max_attempts` | `int` | Maximum number of status checks. Default `23`, range 1–23. |
+
+### `RedactionLevel`
+
+How one entity type displays in `reidentify_string` and `reidentify_file`.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `entity_name` | `EntityType` | Entity type to apply the setting to. See [`EntityType`](#entitytype). |
+| `redaction_type` | `RedactionType` | How the value displays. See [`RedactionType`](#redactiontype). |
+
+The class also accepts `token_group_name` and `redaction_pattern`, which apply to FlowVault vaults.
+
+### `DetectedEntity`
+
+A detected entity, returned in `DeidentifyStringResponse.entities`.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `token` | `str` | The token that replaces the entity. |
+| `value` | `str` | The original value. |
+| `location` | `EntityLocation \| None` | Position in the input and processed text. See [`EntityLocation`](#entitylocation). |
+| `entity_type` | `str` | The highest-rated entity type. |
+| `entity_scores` | `dict[str, float]` | Entity types and their scores. Defaults to `{}`. |
+
+### `EntityLocation`
 
 | Attribute | Type | Description |
 |-----------|------|-------------|
-| `gain` | `float` | Loudness in dB. |
-| `frequency` | `float` | Pitch in Hz. |
-| `start_padding` | `float` | Padding at start (seconds). |
-| `stop_padding` | `float` | Padding at end (seconds). |
+| `start_index` | `int` | Index of the first character in the input text. |
+| `end_index` | `int` | Index of the last character in the input text. |
+| `start_index_processed` | `int` | Index of the first character in the processed text. |
+| `end_index_processed` | `int` | Index of the last character in the processed text. |
+
+### `FileOutput`
+
+A processed output, returned in the `output` list of file responses.
 
-### `File`
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `processed_file` | `str` | The processed content. Base64-encoded when the response's `output_type` is `BASE64`. |
+| `processed_file_type` | `str` | Kind of output, for example `REDACTED_FILE` or `ENTITIES`. |
+| `processed_file_extension` | `FileDataFormat \| None` | Extension of the output. See [`FileDataFormat`](#filedataformat). |
 
-Wrapper around the processed file returned in `DeidentifyFileResponse.file`.
+### `Metrics`
 
-| Member | Kind | Description |
-|--------|------|-------------|
-| `name` | property | File name. |
-| `size` | property | Size in bytes. |
-| `type` | property | MIME/type string. |
-| `last_modified` | property | Last-modified timestamp. |
-| `seek(offset, whence=0)` | method | Seek within the file. |
-| `read(size=-1)` | method | Read file content. |
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `size` | `float` | Size of the input, in KB. |
+| `word_count` | `int` | Number of words processed. |
+| `character_count` | `int` | Number of characters processed. |
+| `slides` | `int` | Number of slides processed. |
+| `pages` | `int` | Number of pages processed. |
+| `duration` | `float` | Duration processed, in seconds. |
 
 ---
 
diff --git a/skyvault/README.md b/skyvault/README.md
index 79700e31..fc34b025 100644
--- a/skyvault/README.md
+++ b/skyvault/README.md
@@ -41,10 +41,12 @@ The Skyflow Python SDK is designed to help with integrating Skyflow into a Pytho
         - [Retrieve Existing Tokens: `.tokenize(request)`](#retrieve-existing-tokens-tokenizerequest)
             - [Construct a `.tokenize()` request](#construct-a-tokenize-request)
     - [Detect](#detect)
-        - [De-identify Text: `.deidentify_text(request)`](#de-identify-text-deidentify_textrequest)
-        - [Re-identify Text: `.reidentify_text(request)`](#re-identify-text-reidentify_textrequest)
+        - [De-identify String: `.deidentify_string(request)`](#de-identify-string-deidentify_stringrequest)
         - [De-identify File: `.deidentify_file(request)`](#de-identify-file-deidentify_filerequest)
-        - [Get Run: `.get_detect_run(request)`](#get-run-get_detect_runrequest)
+        - [Get Run: `.get_run(request)`](#get-run-get_runrequest)
+        - [Re-identify String: `.reidentify_string(request)`](#re-identify-string-reidentify_stringrequest)
+        - [Re-identify File: `.reidentify_file(request)`](#re-identify-file-reidentify_filerequest)
+        - [Check Guardrails: `.check_guardrails(request)`](#check-guardrails-check_guardrailsrequest)
     - [Connections](#connections)
         - [Invoke a connection](#invoke-a-connection)
             - [Construct an invoke connection request](#construct-an-invoke-connection-request)
@@ -548,142 +550,256 @@ Tokenization result: TokenizeResponse(tokenized_fields=[{'token': 'a1b2c3d4-...'
 
 ## Detect
 
-De-identify and reidentify sensitive data in text and files using Skyflow Detect, which supports advanced privacy-preserving workflows.
+De-identify sensitive data in strings and files, re-identify the results, and check text against guardrails using Skyflow Detect. The Detect V2 API is in beta.
 
-### De-identify Text: `.deidentify_text(request)`
+Get a Detect controller with `skyflow_client.detect('<VAULT_ID>')`. If you omit the vault ID, the controller uses the first vault configuration you added. Import request classes from `skyflow.vault.detect` and enums from `skyflow.utils.enums`.
 
-De-identify or anonymize text using the `deidentify_text` method.
+> [!NOTE]
+> Detect V2 replaces the `deidentify_text`, `reidentify_text`, and `get_detect_run` methods and their request and response classes. Use `deidentify_string`, `reidentify_string`, and `get_run` instead. `deidentify_file` keeps its name and takes the `DeidentifyFileRequest` fields described in [De-identify File](#de-identify-file-deidentify_filerequest).
+
+Each Detect method raises a `SkyflowError` when the request fails validation or the API returns an error. See [Error handling](#error-handling).
+
+### De-identify String: `.deidentify_string(request)`
+
+De-identify sensitive data in a string using the `deidentify_string` method. Build the request with the [`DeidentifyStringRequest`](../docs/api_reference.md#deidentifystringrequest) class, and specify how Detect finds and de-identifies entities in one of two ways:
 
-Create a de-identify text request with the [`DeidentifyTextRequest`](../docs/api_reference.md#deidentifytextrequest) class.
+- Set `configuration_id` to the ID of an existing Detect configuration.
+- Set `configuration` to an inline [`DetectConfiguration`](../docs/api_reference.md#detectconfiguration).
+
+The SDK has no methods to create or manage Detect configurations.
 
 ```python
-from skyflow.vault.detect import DeidentifyTextRequest, TokenFormat, Transformations, DateTransformation
-from skyflow.utils.enums import DetectEntities, TokenType
+from skyflow.vault.detect import DeidentifyStringRequest
 
-request = DeidentifyTextRequest(
-    text="<TEXT_TO_BE_DEIDENTIFIED>",
-    entities=[DetectEntities.SSN, DetectEntities.CREDIT_CARD],
-    token_format=TokenFormat(default=TokenType.VAULT_TOKEN),
-    transformations=Transformations(
-        shift_dates=DateTransformation(
-            max_days=30, # Maximum days to shift
-            min_days=10, # Minimum days to shift
-            entities=[DetectEntities.DOB]
-        )
-    )
+request = DeidentifyStringRequest(
+    text='My name is John Doe, and my email is johndoe@acme.com.',
+    configuration_id='<CONFIGURATION_ID>'
 )
 
-response = skyflow_client.detect('<VAULT_ID>').deidentify_text(request)
-print('De-identify Text Response:', response)
+response = skyflow_client.detect('<VAULT_ID>').deidentify_string(request)
+print('De-identified text:', response.processed_text)
+for entity in response.entities:
+    print(entity.entity_type, entity.token, entity.entity_scores)
 ```
 
-Returns a [`DeidentifyTextResponse`](../docs/api_reference.md#deidentifytextresponse) (`processed_text`, `entities`, `word_count`, `char_count`, `errors`). `entities` is a list of [`EntityInfo`](../docs/api_reference.md#entityinfo) describing each detected entity:
+To define the configuration inline, list each entity type to detect and its de-identification type. For `VAULT_TOKEN`, set `destination` to the vault column that stores the detected value, in `table.column` format:
 
-```text
-De-identify Text Response: DeidentifyTextResponse(processed_text='My SSN is [SSN_1].', entities=[...], word_count=4, char_count=18, errors=None)
+```python
+from skyflow.vault.detect import DeidentifyStringRequest, DetectConfiguration, Detect, Entity
+from skyflow.utils.enums import EntityType, DeidentificationType
+
+request = DeidentifyStringRequest(
+    text='My name is John Doe, and my email is johndoe@acme.com.',
+    configuration=DetectConfiguration(
+        detect=Detect(entities=[
+            Entity(
+                entity_type=EntityType.NAME,
+                deidentification_type=DeidentificationType.VAULT_TOKEN,
+                destination='<TABLE_NAME>.<COLUMN_NAME>'
+            ),
+            Entity(
+                entity_type=EntityType.EMAIL_ADDRESS,
+                deidentification_type=DeidentificationType.ENTITY_UNIQUE_COUNTER
+            )
+        ])
+    )
+)
+
+response = skyflow_client.detect('<VAULT_ID>').deidentify_string(request)
 ```
 
+Returns a [`DeidentifyStringResponse`](../docs/api_reference.md#deidentifystringresponse) (`processed_text`, `entities`, `metrics`). Each item in `entities` is a [`DetectedEntity`](../docs/api_reference.md#detectedentity) with the entity's `token`, `value`, `location`, `entity_type`, and `entity_scores`.
+
 > [!TIP]
-> See the full example in the samples directory: [deidentify_text.py](samples/detect_api/deidentify_text.py)
+> See the full example in the samples directory: [deidentify_string.py](samples/detect_api/deidentify_string.py)
+
+### De-identify File: `.deidentify_file(request)`
+
+De-identify a file using the `deidentify_file` method. Build the request with the [`DeidentifyFileRequest`](../docs/api_reference.md#deidentifyfilerequest) class. Set `configuration_id` or `configuration` as you would for a string, and supply the file in one of these ways:
 
-### Re-identify Text: `.reidentify_text(request)`
+- `file_path`: the path to a local file.
+- `file`: a local file opened in binary mode.
+- `data_source` and `value`: base64-encoded content (`DataSourceType.BASE64`), a file stored in the vault (`DataSourceType.SKYFLOW_ID`), or a presigned URL (`DataSourceType.PRESIGNED_URL`).
 
-Re-identify text using the `reidentify_text` method. Create a reidentify text request with the [`ReidentifyTextRequest`](../docs/api_reference.md#reidentifytextrequest) class, which includes the redacted or de-identified text to be re-identified.
+For a local file, the SDK base64-encodes the content and infers `data_format` from the file extension unless you set it.
+
+Detect processes files asynchronously. By default, `deidentify_file` submits the run and returns a `run_id` with a `status` of `None`. Pass the `run_id` to [`get_run`](#get-run-get_runrequest) to retrieve the result.
 
 ```python
-from skyflow.vault.detect import ReidentifyTextRequest
-from skyflow.utils.enums import DetectEntities
+from skyflow.vault.detect import DeidentifyFileRequest
 
-request = ReidentifyTextRequest(
-    text="<REDACTED_TEXT_TO_REIDENTIFY>",
-    redacted_entities=[DetectEntities.SSN],        # Keep redacted
-    masked_entities=[DetectEntities.CREDIT_CARD],  # Mask
-    plain_text_entities=[DetectEntities.NAME]      # Reveal
+request = DeidentifyFileRequest(
+    file_path='<PATH_TO_FILE>',
+    configuration_id='<CONFIGURATION_ID>'
 )
 
-response = skyflow_client.detect().reidentify_text(request)
-print('Re-identify Text Response:', response)
+response = skyflow_client.detect('<VAULT_ID>').deidentify_file(request)
+print('Run ID:', response.run_id)
 ```
 
-Returns a [`ReidentifyTextResponse`](../docs/api_reference.md#reidentifytextresponse) (`processed_text`, `errors`):
+To wait for the result in the same call, set `poll_options` to a [`PollOptions`](../docs/api_reference.md#polloptions) object. The SDK checks the run with exponential backoff, waiting 1, 2, 4, 8, 16, and then 32 seconds between attempts. Polling stops when the first of these happens:
 
-```text
-Re-identify Text Response: ReidentifyTextResponse(processed_text='John lives in NYC', errors=None)
+- The run reaches `SUCCESS`, `FAILED`, or `UNKNOWN`.
+- The total wait reaches `wait_time` (default 60 seconds, maximum 300).
+- The number of attempts reaches `max_attempts` (default and maximum 23).
+
+If polling stops before the run finishes, the response carries the current status, such as `QUEUED` or `IN_PROGRESS`. Call `get_run` later to retrieve the result.
+
+When a polled run on a local `file` or `file_path` succeeds, the SDK writes each base64-encoded output to disk with a `processed-` prefix. For example, the processed copy of `notes.pdf` is `processed-notes.pdf`, and its entities output is `processed-entities-notes.json`. Set `output_directory` to choose where the files go; the SDK creates the directory if it doesn't exist. Without `output_directory`, the SDK writes to the current working directory. `output_directory` requires `poll_options`.
+
+```python
+from skyflow.vault.detect import DeidentifyFileRequest, PollOptions
+from skyflow.utils.enums import DetectRunStatus
+
+request = DeidentifyFileRequest(
+    file_path='<PATH_TO_FILE>',
+    configuration_id='<CONFIGURATION_ID>',
+    poll_options=PollOptions(wait_time=120),
+    output_directory='<OUTPUT_DIRECTORY>'
+)
+
+response = skyflow_client.detect('<VAULT_ID>').deidentify_file(request)
+
+if response.status == DetectRunStatus.SUCCESS:
+    for output in response.output:
+        print(output.processed_file_type, output.processed_file_extension)
+elif response.status in (DetectRunStatus.QUEUED, DetectRunStatus.IN_PROGRESS):
+    print('Still running. Call get_run later with run ID:', response.run_id)
+else:
+    print('Run ended with status:', response.status, response.message)
+```
+
+To de-identify a file that's stored in the vault or available at a presigned URL, set `data_source` and `value`. The SDK doesn't write outputs to disk for these requests.
+
+```python
+from skyflow.vault.detect import DeidentifyFileRequest
+from skyflow.utils.enums import DataSourceType, FileDataFormat
+
+request = DeidentifyFileRequest(
+    data_source=DataSourceType.PRESIGNED_URL,
+    value='<PRESIGNED_URL>',
+    data_format=FileDataFormat.PDF,
+    configuration_id='<CONFIGURATION_ID>'
+)
+
+response = skyflow_client.detect('<VAULT_ID>').deidentify_file(request)
+print('Run ID:', response.run_id)
 ```
 
+Returns a [`DeidentifyFileResponse`](../docs/api_reference.md#deidentifyfileresponse) (`run_id`, `status`, `output_type`, `output`, `metrics`, `message`). Each item in `output` is a [`FileOutput`](../docs/api_reference.md#fileoutput).
+
+Supported formats are the members of [`FileDataFormat`](../docs/api_reference.md#filedataformat). The `VAULT_TOKEN` de-identification type supports only `txt`, `json`, `csv`, `xml`, `jsonl`, `docx`, `xlsx`, and `pptx` files.
+
 > [!TIP]
-> See the full example in the samples directory: [reidentify_text.py](samples/detect_api/reidentify_text.py)
+> See the full example in the samples directory: [deidentify_file.py](samples/detect_api/deidentify_file.py)
 
-### De-identify File: `.deidentify_file(request)`
+### Get Run: `.get_run(request)`
 
-De-identify files using the `deidentify_file` method. Create a request with the [`DeidentifyFileRequest`](../docs/api_reference.md#deidentifyfilerequest) class, which includes the file to be deidentified. Provide optional parameters to control how entities are detected and deidentified.
+Retrieve the status and outputs of a file de-identification run using the `get_run` method. Build the request with the [`GetRunRequest`](../docs/api_reference.md#getrunrequest) class, initialized with the `run_id` that `deidentify_file` returned.
 
 ```python
-from skyflow.vault.detect import DeidentifyFileRequest, TokenFormat, FileInput
-from skyflow.utils.enums import DetectEntities, TokenType
+from skyflow.vault.detect import GetRunRequest
+from skyflow.utils.enums import DetectRunStatus
 
-# Open file in binary mode
-with open('path/to/file.pdf', 'rb') as file_obj:
-    request = DeidentifyFileRequest(
-        file=FileInput(file_obj),
-        entities=[DetectEntities.SSN, DetectEntities.CREDIT_CARD],
-        token_format=TokenFormat(default=TokenType.ENTITY_ONLY),
-        output_directory='<OUTPUT_DIR>',
-        wait_time=64
-    )
+request = GetRunRequest(run_id='<RUN_ID>')
 
-    response = skyflow_client.detect().deidentify_file(request)
-    print('De-identify File Response:', response)
+response = skyflow_client.detect('<VAULT_ID>').get_run(request)
+print('Run status:', response.status)
+if response.status == DetectRunStatus.SUCCESS:
+    for output in response.output:
+        print(output.processed_file_type, output.processed_file_extension)
 ```
 
-Returns a [`DeidentifyFileResponse`](../docs/api_reference.md#deidentifyfileresponse) with the processed file plus metadata (`file`, `type`, `extension`, `word_count`, `char_count`, `size_in_kb`, `entities`, `run_id`, `status`, `errors`, and more — see the [API Reference](../docs/api_reference.md#response-objects)). If processing exceeds `wait_time`, only `run_id` and `status` are returned (poll with `get_detect_run`):
+Returns a [`GetRunResponse`](../docs/api_reference.md#getrunresponse) (`run_id`, `status`, `output_type`, `output`, `metrics`, `message`). `get_run` doesn't write outputs to disk. When `output_type` is `BASE64`, decode each `processed_file` yourself.
 
-```text
-De-identify File Response: DeidentifyFileResponse(file_base64=None, file=<File ...>, type='application/pdf', extension='pdf', ..., run_id='r-9c1f2a3b', status='SUCCESS', errors=None)
-```
+> [!TIP]
+> See the full example in the samples directory: [get_run.py](samples/detect_api/get_run.py)
+
+### Re-identify String: `.reidentify_string(request)`
 
-**Supported file types:**
+Replace the tokens in de-identified text with their original, masked, or redacted values using the `reidentify_string` method. Build the request with the [`ReidentifyStringRequest`](../docs/api_reference.md#reidentifystringrequest) class. To control how each entity type displays, pass a list of [`RedactionLevel`](../docs/api_reference.md#redactionlevel) objects in `redaction_level`. Each one pairs an `entity_name` from `EntityType` with a `redaction_type` from `RedactionType` (see [Redaction Types](#redaction-types)).
 
-- Documents: `doc`, `docx`, `pdf`
-- PDFs: `pdf`
-- Images: `bmp`, `jpeg`, `jpg`, `png`, `tif`, `tiff`
-- Structured text: `json`, `xml`
-- Spreadsheets: `csv`, `xls`, `xlsx`
-- Presentations: `ppt`, `pptx`
-- Audio: `mp3`, `wav`
+Re-identification requires the Detect Invoker, Detect Manager, or Vault Owner role. To re-identify vault tokens without the Vault Owner role, you also need a policy that grants the Detokenization action.
 
-**Notes:**
+```python
+from skyflow.vault.detect import ReidentifyStringRequest, RedactionLevel
+from skyflow.utils.enums import EntityType, RedactionType
+
+request = ReidentifyStringRequest(
+    text='<DEIDENTIFIED_TEXT>',
+    redaction_level=[
+        RedactionLevel(entity_name=EntityType.NAME, redaction_type=RedactionType.PLAIN_TEXT),
+        RedactionLevel(entity_name=EntityType.EMAIL_ADDRESS, redaction_type=RedactionType.MASKED)
+    ]
+)
+
+response = skyflow_client.detect('<VAULT_ID>').reidentify_string(request)
+print('Re-identified text:', response.processed_text)
+```
 
-- Transformations can't be applied to Documents, Images, or PDFs file formats.
-- The `wait_time` option must be ≤ 64 seconds; otherwise, an error is thrown.
-- If the API takes more than 64 seconds to process the file, it will return only the `run_id` and `status` in the response.
+Returns a [`ReidentifyStringResponse`](../docs/api_reference.md#reidentifystringresponse) (`processed_text`, `metrics`).
 
 > [!TIP]
-> See the full example in the samples directory: [deidentify_file.py](samples/detect_api/deidentify_file.py)
+> See the full example in the samples directory: [reidentify_string.py](samples/detect_api/reidentify_string.py)
 
-### Get Run: `.get_detect_run(request)`
+### Re-identify File: `.reidentify_file(request)`
 
-Retrieve the results of a previously started file de-identification operation using the `get_detect_run` method. Build the request with the [`GetDetectRunRequest`](../docs/api_reference.md#getdetectrunrequest) class, initialized with the `run_id` returned from a prior `deidentify_file` call.
+Re-identify the tokens in a file using the `reidentify_file` method. Build the request with the [`ReidentifyFileRequest`](../docs/api_reference.md#reidentifyfilerequest) class. Supply the file with `data_source` and `value`, set `data_format`, and set `redaction_level` as you would for a string. The method doesn't accept `file` or `file_path`, so base64-encode a local file yourself. Supported formats are `txt`, `csv`, `json`, `xlsx`, `docx`, `pptx`, `xml`, and `jsonl`.
 
-```python
-from skyflow.vault.detect import GetDetectRunRequest
+`reidentify_file` is synchronous: the response contains the re-identified file. It needs the same roles as `reidentify_string`.
 
-request = GetDetectRunRequest(
-    run_id='<RUN_ID_FROM_DEIDENTIFY_FILE>'
+```python
+import base64
+from skyflow.vault.detect import ReidentifyFileRequest, RedactionLevel
+from skyflow.utils.enums import DataSourceType, FileDataFormat, DetectRunStatus, EntityType, RedactionType
+
+with open('<PATH_TO_DEIDENTIFIED_FILE>', 'rb') as file_obj:
+    encoded_file = base64.b64encode(file_obj.read()).decode('utf-8')
+
+request = ReidentifyFileRequest(
+    data_source=DataSourceType.BASE64,
+    value=encoded_file,
+    data_format=FileDataFormat.TXT,
+    redaction_level=[
+        RedactionLevel(entity_name=EntityType.NAME, redaction_type=RedactionType.PLAIN_TEXT)
+    ]
 )
 
-response = skyflow_client.detect().get_detect_run(request)
-print('Get Detect Run Response:', response)
+response = skyflow_client.detect('<VAULT_ID>').reidentify_file(request)
+if response.status == DetectRunStatus.SUCCESS and response.output_type == DataSourceType.BASE64:
+    for index, output in enumerate(response.output):
+        with open(f'reidentified-{index}.txt', 'wb') as out_file:
+            out_file.write(base64.b64decode(output.processed_file))
 ```
 
-Returns a [`DeidentifyFileResponse`](../docs/api_reference.md#deidentifyfileresponse) with the current `status` for the run (and the processed file once `status` is complete):
+Returns a [`ReidentifyFileResponse`](../docs/api_reference.md#reidentifyfileresponse) (`status`, `output_type`, `output`, `metrics`). The SDK doesn't write the output to disk.
 
-```text
-Get Detect Run Response: DeidentifyFileResponse(file_base64=None, file=None, ..., run_id='r-9c1f2a3b', status='IN_PROGRESS', errors=None)
+> [!TIP]
+> See the full example in the samples directory: [reidentify_file.py](samples/detect_api/reidentify_file.py)
+
+### Check Guardrails: `.check_guardrails(request)`
+
+Check text for toxicity and denied topics using the `check_guardrails` method. Build the request with the [`CheckGuardrailsRequest`](../docs/api_reference.md#checkguardrailsrequest) class. Set `check_toxicity=True` to check for toxicity, and list the topics to deny in `deny_topics`.
+
+```python
+from skyflow.vault.detect import CheckGuardrailsRequest
+from skyflow.utils.enums import GuardrailsValidation
+
+request = CheckGuardrailsRequest(
+    text='<TEXT_TO_CHECK>',
+    check_toxicity=True,
+    deny_topics=['politics', 'medical advice']
+)
+
+response = skyflow_client.detect('<VAULT_ID>').check_guardrails(request)
+if response.validation == GuardrailsValidation.FAILED:
+    print('Text failed guardrails. Toxic:', response.toxic, 'Denied topic:', response.denied_topic)
 ```
 
+Returns a [`CheckGuardrailsResponse`](../docs/api_reference.md#checkguardrailsresponse) (`text`, `validation`, `toxic`, `denied_topic`). `validation` is `PASSED`, `FAILED`, or `UNKNOWN`.
+
 > [!TIP]
-> See the full example in the samples directory: [get_detect_run.py](samples/detect_api/get_detect_run.py)
+> See the full example in the samples directory: [check_guardrails.py](samples/detect_api/check_guardrails.py)
 
 ## Connections
 
diff --git a/skyvault/samples/README.md b/skyvault/samples/README.md
index e3d20c42..f01dd384 100644
--- a/skyvault/samples/README.md
+++ b/skyvault/samples/README.md
@@ -1,6 +1,6 @@
 # Skyflow Python SDK — Samples
 
-Runnable examples for the Skyflow Python SDK, grouped by area. Start with the [README](../README.md) and [API Reference](../docs/api_reference.md) for full documentation.
+Runnable examples for the Skyflow Python SDK, grouped by area. Start with the [README](../README.md) and [API Reference](../../docs/api_reference.md) for full documentation.
 
 ## Prerequisites
 
@@ -43,15 +43,16 @@ Core vault data operations.
 | `invoke_connection.py` | Invoking a Skyflow Connection |
 
 ### `detect_api/`
-Skyflow Detect (de-identification / re-identification).
+Skyflow Detect V2 de-identification, re-identification, and guardrail checks.
 
 | Sample | Demonstrates |
 |--------|--------------|
-| `deidentify_text.py` | De-identifying text |
-| `reidentify_text.py` | Re-identifying text |
-| `deidentify_file.py` | De-identifying a file |
-| `deidentify_file_async.py` | Running a file de-identification on a background thread (thread-based concurrency, not asyncio) |
-| `get_detect_run.py` | Polling a file de-identification run by `run_id` |
+| `deidentify_string.py` | De-identifying a string with a stored or inline Detect configuration |
+| `deidentify_file.py` | De-identifying a local file, polling for the result, and writing the processed files |
+| `get_run.py` | Retrieving a file de-identification run by `run_id` and saving its outputs |
+| `reidentify_string.py` | Re-identifying a string with per-entity redaction types |
+| `reidentify_file.py` | Re-identifying a base64-encoded file and saving the result |
+| `check_guardrails.py` | Checking text for toxicity and denied topics |
 
 ### `service_account/`
 Bearer-token and signed-data-token generation.
diff --git a/skyvault/samples/detect_api/check_guardrails.py b/skyvault/samples/detect_api/check_guardrails.py
new file mode 100644
index 00000000..2f80b7ea
--- /dev/null
+++ b/skyvault/samples/detect_api/check_guardrails.py
@@ -0,0 +1,65 @@
+from skyflow.error import SkyflowError
+from skyflow import Env, Skyflow, LogLevel
+from skyflow.utils.enums import GuardrailsValidation
+from skyflow.vault.detect import CheckGuardrailsRequest
+
+"""
+ * Skyflow Check Guardrails Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. Check text for toxicity and denied topics
+ * 4. Handle response and errors
+"""
+
+def perform_check_guardrails():
+    try:
+        # Step 1: Configure Credentials
+        credentials = {
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
+        }
+
+        # Step 2: Configure Vault
+        vault_config = {
+            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
+            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
+            'env': Env.PROD,  # Deployment environment
+            'credentials': credentials
+        }
+
+        # Step 3: Configure & Initialize Skyflow Client
+        skyflow_client = (
+            Skyflow.builder()
+            .add_vault_config(vault_config)
+            .set_log_level(LogLevel.ERROR)
+            .build()
+        )
+
+        # Step 4: Create the request
+        request = CheckGuardrailsRequest(
+            text='<TEXT_TO_CHECK>',
+            check_toxicity=True,  # Check the text for toxicity
+            deny_topics=['politics', 'medical advice']  # Topics to deny
+        )
+
+        # Step 5: Check the text
+        response = skyflow_client.detect(vault_config.get('vault_id')).check_guardrails(request)
+
+        print('Validation:', response.validation, 'Toxic:', response.toxic, 'Denied topic:', response.denied_topic)
+        if response.validation == GuardrailsValidation.FAILED:
+            print('The text failed the guardrails check.')
+
+    except SkyflowError as error:
+        # Handle Skyflow-specific errors
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
+    except Exception as error:
+        # Handle unexpected errors
+        print('Unexpected Error:', error)
+
+# Invoke the check guardrails function
+perform_check_guardrails()
diff --git a/skyvault/samples/detect_api/deidentify_file.py b/skyvault/samples/detect_api/deidentify_file.py
index 88f012c9..0dfba782 100644
--- a/skyvault/samples/detect_api/deidentify_file.py
+++ b/skyvault/samples/detect_api/deidentify_file.py
@@ -1,29 +1,24 @@
 from skyflow.error import SkyflowError
 from skyflow import Env, Skyflow, LogLevel
-from skyflow.utils.enums import DetectEntities, MaskingMethod, DetectOutputTranscriptions
-from skyflow.vault.detect import (
-    DeidentifyFileRequest,
-    TokenFormat,
-    Transformations,
-    DateTransformation,
-    Bleep,
-    FileInput,
-)
+from skyflow.utils.enums import DetectRunStatus
+from skyflow.vault.detect import DeidentifyFileRequest, PollOptions
 
 """
- * Skyflow Deidentify File Example
- * 
- * This sample demonstrates how to use all available options for deidentifying files.
- * Supported file types: images (jpg, png, etc.), pdf, audio (mp3, wav), documents, 
- * spreadsheets, presentations, structured text.
+ * Skyflow De-identify File Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. Submit a local file for de-identification and poll for the result
+ * 4. Write the processed files to an output directory
+ * 5. Handle response and errors
 """
 
-
-def perform_file_deidentification():
+def perform_deidentify_file():
     try:
         # Step 1: Configure Credentials
         credentials = {
-            'path': '/path/to/credentials.json'  # Path to credentials file
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
         }
 
         # Step 2: Configure Vault
@@ -31,79 +26,53 @@ def perform_file_deidentification():
             'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
             'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
             'env': Env.PROD,  # Deployment environment
-            'credentials': credentials,
+            'credentials': credentials
         }
 
         # Step 3: Configure & Initialize Skyflow Client
         skyflow_client = (
             Skyflow.builder()
             .add_vault_config(vault_config)
-            .set_log_level(LogLevel.INFO)  # Use LogLevel.ERROR in production
+            .set_log_level(LogLevel.ERROR)
             .build()
         )
 
-        # Step 4: Create File Object
-        file_path = '<FILE_PATH>'  # Replace with your file path
-
-        # Step 5: Configure Deidentify File Request and call API
-        with open(file_path, 'rb') as file:
-            deidentify_request = DeidentifyFileRequest(
-                file=FileInput(file),  # File to de-identify (can also provide a file path)
-                entities=[DetectEntities.SSN, DetectEntities.CREDIT_CARD],  # Entities to detect
-                allow_regex_list=['<YOUR_REGEX_PATTERN>'],  # Optional: Patterns to allow
-                restrict_regex_list=['<YOUR_REGEX_PATTERN>'],  # Optional: Patterns to restrict
-                # Token format configuration
-                token_format=TokenFormat(
-                    vault_token=[DetectEntities.SSN],  # Use vault tokens for these entities
-                ),
-                # Optional: Custom transformations
-                # transformations=Transformations(
-                #     shift_dates=DateTransformation(
-                #         max_days=30,
-                #         min_days=10,
-                #         entities=[DetectEntities.DOB]
-                #     )
-                # ),
-                # Output configuration
-                output_directory='<OUTPUT_DIRECTORY_PATH>',  # Where to save processed file
-                wait_time=15,  # Max wait time in seconds (max 64)
-                # Image-specific options
-                output_processed_image=True,  # Include processed image in output
-                output_ocr_text=True,  # Include OCR text in response
-                masking_method=MaskingMethod.BLACKBOX,  # Masking method for images
-                # PDF-specific options
-                pixel_density=15,  # Pixel density for PDF processing
-                max_resolution=2000,  # Max resolution for PDF
-                # Audio-specific options
-                output_processed_audio=True,  # Include processed audio
-                output_transcription=DetectOutputTranscriptions.PLAINTEXT_TRANSCRIPTION,  # Transcription type
-                # Audio bleep configuration
-                # bleep=Bleep(
-                #     gain=5,  # Loudness in dB
-                #     frequency=1000,  # Pitch in Hz
-                #     start_padding=0.1,  # Padding at start (seconds)
-                #     stop_padding=0.2  # Padding at end (seconds)
-                # )
-            )
+        # Step 4: Create the request
+        # Without poll_options, deidentify_file only submits the run and returns its run_id.
+        # With poll_options, the SDK polls until the run finishes or a polling limit is reached.
+        request = DeidentifyFileRequest(
+            file_path='<PATH_TO_FILE>',  # Local file to de-identify
+            configuration_id='<CONFIGURATION_ID>',  # ID of an existing Detect configuration
+            poll_options=PollOptions(
+                wait_time=120,  # Maximum total wait in seconds (1-300, default 60)
+                max_attempts=10  # Maximum status checks (1-23, default 23)
+            ),
+            output_directory='<OUTPUT_DIRECTORY>'  # Where processed files are written; requires poll_options
+        )
 
-            # Step 6: Call deidentifyFile API
-            response = skyflow_client.detect().deidentify_file(deidentify_request)
+        # Step 5: De-identify the file
+        response = skyflow_client.detect(vault_config.get('vault_id')).deidentify_file(request)
 
-        # Handle Successful Response
-        print('\nDeidentify File Response:', response)
+        print('Run ID:', response.run_id, 'Status:', response.status)
+        if response.status == DetectRunStatus.SUCCESS:
+            # The SDK has written each output to output_directory with a 'processed-' prefix
+            for output in response.output:
+                print(output.processed_file_type, output.processed_file_extension)
+        elif response.status in (DetectRunStatus.QUEUED, DetectRunStatus.IN_PROGRESS):
+            print('Still running. Call get_run later with run ID:', response.run_id)
+        else:
+            print('Run ended with status:', response.status, response.message)
 
     except SkyflowError as error:
         # Handle Skyflow-specific errors
-        print(
-            '\nSkyflow Error:',
-            {
-                'http_code': error.http_code,
-                'grpc_code': error.grpc_code,
-                'http_status': error.http_status,
-                'message': error.message,
-                'details': error.details,
-            },
-        )
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
     except Exception as error:
         # Handle unexpected errors
         print('Unexpected Error:', error)
+
+# Invoke the de-identify file function
+perform_deidentify_file()
diff --git a/skyvault/samples/detect_api/deidentify_file_async.py b/skyvault/samples/detect_api/deidentify_file_async.py
deleted file mode 100644
index d3144f3c..00000000
--- a/skyvault/samples/detect_api/deidentify_file_async.py
+++ /dev/null
@@ -1,125 +0,0 @@
-from skyflow.error import SkyflowError
-from skyflow import Env, Skyflow, LogLevel
-from skyflow.utils.enums import DetectEntities, MaskingMethod, DetectOutputTranscriptions
-from skyflow.vault.detect import (
-    DeidentifyFileRequest,
-    TokenFormat,
-    Transformations,
-    DateTransformation,
-    Bleep,
-    FileInput,
-)
-from concurrent.futures import ThreadPoolExecutor
-
-"""
- * Skyflow Deidentify File Example (concurrent)
- *
- * This sample demonstrates how to use all available options for deidentifying files.
- * The SDK is synchronous; this example runs the (blocking) deidentify_file call on a
- * background thread using concurrent.futures.ThreadPoolExecutor so the main thread can
- * continue working. This is thread-based concurrency, not asyncio — the SDK does not
- * expose async/await coroutines.
- * Supported file types: images (jpg, png, etc.), pdf, audio (mp3, wav), documents,
- * spreadsheets, presentations, structured text.
-"""
-
-def perform_file_deidentification_concurrent():
-    try:
-        # Step 1: Configure Credentials
-        credentials = {
-            'path': '/path/to/credentials.json'  # Path to credentials file
-        }
-
-        # Step 2: Configure Vault
-        vault_config = {
-            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
-            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
-            'env': Env.PROD,  # Deployment environment
-            'credentials': credentials,
-        }
-
-        # Step 3: Configure & Initialize Skyflow Client
-        skyflow_client = (
-            Skyflow.builder()
-            .add_vault_config(vault_config)
-            .set_log_level(LogLevel.INFO)  # Use LogLevel.ERROR in production
-            .build()
-        )
-
-        # Step 4: Create File Object
-        file_path = '<FILE_PATH>'  # Replace with your file path
-        deidentify_request = DeidentifyFileRequest(
-            file=FileInput(file_path=file_path),  # File to de-identify
-            # entities=[DetectEntities.SSN, DetectEntities.CREDIT_CARD],  # Entities to detect
-            allow_regex_list=['<YOUR_REGEX_PATTERN>'],  # Optional: Patterns to allow
-            restrict_regex_list=['<YOUR_REGEX_PATTERN>'],  # Optional: Patterns to restrict
-            # Token format configuration
-            token_format=TokenFormat(
-                vault_token=[DetectEntities.SSN],  # Use vault tokens for these entities
-            ),
-            # Optional: Custom transformations
-            # transformations=Transformations(
-            #     shift_dates=DateTransformation(
-            #         max_days=30,
-            #         min_days=10,
-            #         entities=[DetectEntities.DOB]
-            #     )
-            # ),
-            # Output configuration
-            output_directory='<OUTPUT_DIRECTORY_PATH>',  # Where to save processed file
-            wait_time=15,  # Max wait time in seconds (max 64)
-            # Image-specific options
-            output_processed_image=True,  # Include processed image in output
-            output_ocr_text=True,  # Include OCR text in response
-            masking_method=MaskingMethod.BLACKBOX,  # Masking method for images
-            # PDF-specific options
-            pixel_density=15,  # Pixel density for PDF processing
-            max_resolution=2000,  # Max resolution for PDF
-            # Audio-specific options
-            output_processed_audio=True,  # Include processed audio
-            output_transcription=DetectOutputTranscriptions.PLAINTEXT_TRANSCRIPTION,  # Transcription type
-            # Audio bleep configuration
-            # bleep=Bleep(
-            #     gain=5,  # Loudness in dB
-            #     frequency=1000,  # Pitch in Hz
-            #     start_padding=0.1,  # Padding at start (seconds)
-            #     stop_padding=0.2  # Padding at end (seconds)
-            # )
-        )
-
-        # Create a thread pool executor
-        executor = ThreadPoolExecutor(max_workers=1)
-
-        future = executor.submit(lambda: skyflow_client.detect().deidentify_file(deidentify_request))
-
-        def handle_response(future):
-            exception = future.exception()
-            if exception is not None:
-                if isinstance(exception, SkyflowError):
-                    # Handle Skyflow-specific errors
-                    print(
-                        '\nSkyflow Error:',
-                        {
-                            'http_code': exception.http_code,
-                            'grpc_code': exception.grpc_code,
-                            'http_status': exception.http_status,
-                            'message': exception.message,
-                            'details': exception.details,
-                        },
-                    )
-                else:
-                    # Handle unexpected errors
-                    print('Unexpected Error:', exception)
-                return
-
-            # Handle Successful Response
-            result = future.result()
-            print('\nDeidentify File Response:', result)
-
-        future.add_done_callback(handle_response)
-
-        executor.shutdown(wait=True)
-
-    except Exception as error:
-        # Handle unexpected errors
-        print('Unexpected Error:', error)
diff --git a/skyvault/samples/detect_api/deidentify_string.py b/skyvault/samples/detect_api/deidentify_string.py
new file mode 100644
index 00000000..17e2d1f5
--- /dev/null
+++ b/skyvault/samples/detect_api/deidentify_string.py
@@ -0,0 +1,88 @@
+from skyflow.error import SkyflowError
+from skyflow import Env, Skyflow, LogLevel
+from skyflow.utils.enums import EntityType, DeidentificationType
+from skyflow.vault.detect import DeidentifyStringRequest, DetectConfiguration, Detect, Entity
+
+"""
+ * Skyflow De-identify String Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. De-identify a string with a stored Detect configuration
+ * 4. De-identify a string with an inline Detect configuration
+ * 5. Handle response and errors
+"""
+
+def perform_deidentify_string():
+    try:
+        # Step 1: Configure Credentials
+        credentials = {
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
+        }
+
+        # Step 2: Configure Vault
+        vault_config = {
+            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
+            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
+            'env': Env.PROD,  # Deployment environment
+            'credentials': credentials
+        }
+
+        # Step 3: Configure & Initialize Skyflow Client
+        skyflow_client = (
+            Skyflow.builder()
+            .add_vault_config(vault_config)
+            .set_log_level(LogLevel.ERROR)
+            .build()
+        )
+
+        sample_text = 'My name is John Doe, and my email is johndoe@acme.com.'
+
+        # Step 4: De-identify with the ID of an existing Detect configuration
+        stored_config_request = DeidentifyStringRequest(
+            text=sample_text,
+            configuration_id='<CONFIGURATION_ID>'  # ID of an existing Detect configuration
+        )
+
+        response = skyflow_client.detect(vault_config.get('vault_id')).deidentify_string(stored_config_request)
+
+        print('De-identified text:', response.processed_text)
+        for entity in response.entities:
+            print(entity.entity_type, entity.token, entity.entity_scores)
+
+        # Step 5: De-identify with an inline Detect configuration
+        inline_config_request = DeidentifyStringRequest(
+            text=sample_text,
+            configuration=DetectConfiguration(
+                detect=Detect(entities=[
+                    Entity(
+                        entity_type=EntityType.NAME,
+                        deidentification_type=DeidentificationType.VAULT_TOKEN,
+                        destination='<TABLE_NAME>.<COLUMN_NAME>'  # Vault column that stores the detected value
+                    ),
+                    Entity(
+                        entity_type=EntityType.EMAIL_ADDRESS,
+                        deidentification_type=DeidentificationType.ENTITY_UNIQUE_COUNTER
+                    )
+                ])
+            )
+        )
+
+        response = skyflow_client.detect(vault_config.get('vault_id')).deidentify_string(inline_config_request)
+
+        print('De-identified text (inline configuration):', response.processed_text)
+
+    except SkyflowError as error:
+        # Handle Skyflow-specific errors
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
+    except Exception as error:
+        # Handle unexpected errors
+        print('Unexpected Error:', error)
+
+# Invoke the de-identify string function
+perform_deidentify_string()
diff --git a/skyvault/samples/detect_api/deidentify_text.py b/skyvault/samples/detect_api/deidentify_text.py
deleted file mode 100644
index c543b6f8..00000000
--- a/skyvault/samples/detect_api/deidentify_text.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from skyflow.error import SkyflowError
-from skyflow import Env, Skyflow, LogLevel
-from skyflow.utils.enums import DetectEntities
-from skyflow.vault.detect import DeidentifyTextRequest, TokenFormat, Transformations, DateTransformation
-
-"""
- * Skyflow Text De-identification Example
- * 
- * This example demonstrates how to:
- * 1. Configure Skyflow client credentials
- * 2. Set up vault configuration
- * 3. Create a deidentify text request with all available options
- * 4. Handle response and errors
-"""
-
-def perform_text_deidentification():
-    try:
-        # Step 1: Configure Credentials
-        credentials = {
-            'path': '/path/to/credentials.json'  # Path to credentials file
-        }
-
-        # Step 2: Configure Vault
-        vault_config = {
-            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
-            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
-            'env': Env.PROD,  # Deployment environment
-            'credentials': credentials
-        }
-
-        # Step 3: Configure & Initialize Skyflow Client
-        skyflow_client = (
-            Skyflow.builder()
-            .add_vault_config(vault_config)
-            .set_log_level(LogLevel.ERROR)
-            .build()
-        )
-
-        # Step 4: Prepare Sample Text
-        sample_text = "My SSN is 123-45-6789 and my card is 4111 1111 1111 1111."
-
-        # Step 5: Configure Token Format
-        token_format = TokenFormat(
-            vault_token=[DetectEntities.CREDIT_CARD, DetectEntities.SSN],  # Use vault tokens for these entities
-        )
-
-        # Step 6: Configure Transformations
-        transformations = Transformations(
-            shift_dates=DateTransformation(
-                max_days=30,  # Maximum days to shift
-                min_days=30,  # Minimum days to shift
-                entities=[DetectEntities.DOB]  # Apply shift to DOB entities
-            )
-        )
-
-        # Step 7: Create Deidentify Request
-        deidentify_request = DeidentifyTextRequest(
-            text=sample_text,
-            entities=[DetectEntities.CREDIT_CARD, DetectEntities.SSN],  # Entities to detect and deidentify
-            token_format=token_format,
-            transformations=transformations,
-            allow_regex_list=['<YOUR_ALLOW_REGEX>'],  # Optional: regex patterns to allow
-            restrict_regex_list=['<YOUR_RESTRICT_REGEX>']  # Optional: regex patterns to restrict
-        )
-
-        # Step 8: Perform Text Deidentification
-        response = skyflow_client.detect().deidentify_text(deidentify_request)
-
-        # Handle Successful Response
-        print("\nDeidentify Text Response:", response)
-
-    except SkyflowError as error:
-        # Handle Skyflow-specific errors
-        print('\nSkyflow Error:', {
-            'http_code': error.http_code,
-            'grpc_code': error.grpc_code,
-            'http_status': error.http_status,
-            'message': error.message,
-            'details': error.details
-        })
-    except Exception as error:
-        print('Unexpected Error:', error)
diff --git a/skyvault/samples/detect_api/get_detect_run.py b/skyvault/samples/detect_api/get_detect_run.py
deleted file mode 100644
index c2380c27..00000000
--- a/skyvault/samples/detect_api/get_detect_run.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from skyflow.error import SkyflowError
-from skyflow import Env, Skyflow, LogLevel
-from skyflow.vault.detect import GetDetectRunRequest
-
-"""
- * Skyflow Get Detect Run Example
- * 
- * This example demonstrates how to:
- * 1. Configure credentials
- * 2. Set up vault configuration
- * 3. Create a get detect run request
- * 4. Call getDetectRun to poll for file processing results
- * 5. Handle response and errors
-"""
-
-def perform_get_detect_run():
-    try:
-        # Step 1: Configure Credentials
-        credentials = {
-            'path': '/path/to/credentials.json'  # Path to credentials file
-        }
-
-        # Step 2: Configure Vault
-        vault_config = {
-            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
-            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
-            'env': Env.PROD,  # Deployment environment
-            'credentials': credentials
-        }
-
-        # Step 3: Configure & Initialize Skyflow Client
-        skyflow_client = (
-            Skyflow.builder()
-            .add_vault_config(vault_config)
-            .set_log_level(LogLevel.INFO)  # Use LogLevel.ERROR in production
-            .build()
-        )
-
-        # Step 4: Create GetDetectRunRequest
-        get_detect_run_request = GetDetectRunRequest(
-            run_id='<RUN_ID_FROM_DEIDENTIFY_FILE>'  # Replace with the runId from deidentifyFile call
-        )
-
-        # Step 5: Call getDetectRun API
-        response = skyflow_client.detect().get_detect_run(get_detect_run_request)
-
-        # Handle Successful Response
-        print("\nGet Detect Run Response:", response)
-
-    except SkyflowError as error:
-        # Handle Skyflow-specific errors
-        print('\nSkyflow Error:', {
-            'http_code': error.http_code,
-            'grpc_code': error.grpc_code,
-            'http_status': error.http_status,
-            'message': error.message,
-            'details': error.details
-        })
-    except Exception as error:
-        # Handle unexpected errors
-        print('Unexpected Error:', error)
diff --git a/skyvault/samples/detect_api/get_run.py b/skyvault/samples/detect_api/get_run.py
new file mode 100644
index 00000000..6705c8e5
--- /dev/null
+++ b/skyvault/samples/detect_api/get_run.py
@@ -0,0 +1,68 @@
+import base64
+
+from skyflow.error import SkyflowError
+from skyflow import Env, Skyflow, LogLevel
+from skyflow.utils.enums import DataSourceType, DetectRunStatus
+from skyflow.vault.detect import GetRunRequest
+
+"""
+ * Skyflow Get Run Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. Retrieve the status and outputs of a file de-identification run
+ * 4. Decode and save the outputs
+ * 5. Handle response and errors
+"""
+
+def perform_get_run():
+    try:
+        # Step 1: Configure Credentials
+        credentials = {
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
+        }
+
+        # Step 2: Configure Vault
+        vault_config = {
+            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
+            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
+            'env': Env.PROD,  # Deployment environment
+            'credentials': credentials
+        }
+
+        # Step 3: Configure & Initialize Skyflow Client
+        skyflow_client = (
+            Skyflow.builder()
+            .add_vault_config(vault_config)
+            .set_log_level(LogLevel.ERROR)
+            .build()
+        )
+
+        # Step 4: Create the request with the run_id that deidentify_file returned
+        request = GetRunRequest(run_id='<RUN_ID>')
+
+        # Step 5: Get the run
+        response = skyflow_client.detect(vault_config.get('vault_id')).get_run(request)
+
+        print('Run ID:', response.run_id, 'Status:', response.status)
+        if response.status == DetectRunStatus.SUCCESS and response.output_type == DataSourceType.BASE64:
+            # get_run doesn't write files, so decode and save each output here
+            for index, output in enumerate(response.output):
+                extension = output.processed_file_extension.value if output.processed_file_extension else 'bin'
+                with open(f'processed-{index}.{extension}', 'wb') as out_file:
+                    out_file.write(base64.b64decode(output.processed_file))
+
+    except SkyflowError as error:
+        # Handle Skyflow-specific errors
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
+    except Exception as error:
+        # Handle unexpected errors
+        print('Unexpected Error:', error)
+
+# Invoke the get run function
+perform_get_run()
diff --git a/skyvault/samples/detect_api/reidentify_file.py b/skyvault/samples/detect_api/reidentify_file.py
new file mode 100644
index 00000000..815eda5b
--- /dev/null
+++ b/skyvault/samples/detect_api/reidentify_file.py
@@ -0,0 +1,78 @@
+import base64
+
+from skyflow.error import SkyflowError
+from skyflow import Env, Skyflow, LogLevel
+from skyflow.utils.enums import DataSourceType, DetectRunStatus, EntityType, FileDataFormat, RedactionType
+from skyflow.vault.detect import ReidentifyFileRequest, RedactionLevel
+
+"""
+ * Skyflow Re-identify File Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. Base64-encode a de-identified file and re-identify it
+ * 4. Decode and save the re-identified file
+ * 5. Handle response and errors
+"""
+
+def perform_reidentify_file():
+    try:
+        # Step 1: Configure Credentials
+        credentials = {
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
+        }
+
+        # Step 2: Configure Vault
+        vault_config = {
+            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
+            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
+            'env': Env.PROD,  # Deployment environment
+            'credentials': credentials
+        }
+
+        # Step 3: Configure & Initialize Skyflow Client
+        skyflow_client = (
+            Skyflow.builder()
+            .add_vault_config(vault_config)
+            .set_log_level(LogLevel.ERROR)
+            .build()
+        )
+
+        # Step 4: Encode the file; reidentify_file doesn't accept file or file_path
+        with open('<PATH_TO_DEIDENTIFIED_FILE>', 'rb') as file_obj:
+            encoded_file = base64.b64encode(file_obj.read()).decode('utf-8')
+
+        request = ReidentifyFileRequest(
+            data_source=DataSourceType.BASE64,
+            value=encoded_file,
+            data_format=FileDataFormat.TXT,  # txt, csv, json, xlsx, docx, pptx, xml, or jsonl
+            redaction_level=[
+                RedactionLevel(entity_name=EntityType.NAME, redaction_type=RedactionType.PLAIN_TEXT)
+            ]
+        )
+
+        # Step 5: Re-identify the file; the response contains the result
+        response = skyflow_client.detect(vault_config.get('vault_id')).reidentify_file(request)
+
+        print('Status:', response.status)
+        if response.status == DetectRunStatus.SUCCESS and response.output_type == DataSourceType.BASE64:
+            # The SDK doesn't write the output, so decode and save it here
+            for index, output in enumerate(response.output):
+                extension = output.processed_file_extension.value if output.processed_file_extension else 'txt'
+                with open(f'reidentified-{index}.{extension}', 'wb') as out_file:
+                    out_file.write(base64.b64decode(output.processed_file))
+
+    except SkyflowError as error:
+        # Handle Skyflow-specific errors
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
+    except Exception as error:
+        # Handle unexpected errors
+        print('Unexpected Error:', error)
+
+# Invoke the re-identify file function
+perform_reidentify_file()
diff --git a/skyvault/samples/detect_api/reidentify_string.py b/skyvault/samples/detect_api/reidentify_string.py
new file mode 100644
index 00000000..525d0a3f
--- /dev/null
+++ b/skyvault/samples/detect_api/reidentify_string.py
@@ -0,0 +1,65 @@
+from skyflow.error import SkyflowError
+from skyflow import Env, Skyflow, LogLevel
+from skyflow.utils.enums import EntityType, RedactionType
+from skyflow.vault.detect import ReidentifyStringRequest, RedactionLevel
+
+"""
+ * Skyflow Re-identify String Example
+ *
+ * This example demonstrates how to:
+ * 1. Configure Skyflow client credentials
+ * 2. Set up vault configuration
+ * 3. Re-identify de-identified text, choosing how each entity type displays
+ * 4. Handle response and errors
+"""
+
+def perform_reidentify_string():
+    try:
+        # Step 1: Configure Credentials
+        credentials = {
+            'path': '<PATH_TO_CREDENTIALS_JSON>'  # Path to your service account credentials file
+        }
+
+        # Step 2: Configure Vault
+        vault_config = {
+            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
+            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
+            'env': Env.PROD,  # Deployment environment
+            'credentials': credentials
+        }
+
+        # Step 3: Configure & Initialize Skyflow Client
+        skyflow_client = (
+            Skyflow.builder()
+            .add_vault_config(vault_config)
+            .set_log_level(LogLevel.ERROR)
+            .build()
+        )
+
+        # Step 4: Create the request
+        request = ReidentifyStringRequest(
+            text='<DEIDENTIFIED_TEXT>',  # Text returned by deidentify_string
+            redaction_level=[
+                RedactionLevel(entity_name=EntityType.NAME, redaction_type=RedactionType.PLAIN_TEXT),  # Reveal
+                RedactionLevel(entity_name=EntityType.EMAIL_ADDRESS, redaction_type=RedactionType.MASKED)  # Mask
+            ]
+        )
+
+        # Step 5: Re-identify the text
+        response = skyflow_client.detect(vault_config.get('vault_id')).reidentify_string(request)
+
+        print('Re-identified text:', response.processed_text)
+
+    except SkyflowError as error:
+        # Handle Skyflow-specific errors
+        print('Skyflow Specific Error: ', {
+            'code': error.http_code,
+            'message': error.message,
+            'details': error.details
+        })
+    except Exception as error:
+        # Handle unexpected errors
+        print('Unexpected Error:', error)
+
+# Invoke the re-identify string function
+perform_reidentify_string()
diff --git a/skyvault/samples/detect_api/reidentify_text.py b/skyvault/samples/detect_api/reidentify_text.py
deleted file mode 100644
index d158733f..00000000
--- a/skyvault/samples/detect_api/reidentify_text.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from skyflow.error import SkyflowError
-from skyflow import Env, Skyflow, LogLevel
-from skyflow.utils.enums import DetectEntities
-from skyflow.vault.detect import ReidentifyTextRequest
-
-"""
- * Skyflow Text Re-identification Example
- * 
- * This example demonstrates how to:
- * 1. Configure credentials
- * 2. Set up vault configuration
- * 3. Create a reidentify text request
- * 4. Use all available options for reidentification
- * 5. Handle response and errors
-"""
-
-def perform_text_reidentification():
-    try:
-        # Step 1: Configure Credentials
-        credentials = {
-            'path': '/path/to/credentials.json'  # Path to credentials file
-        }
-
-        # Step 2: Configure Vault
-        vault_config = {
-            'vault_id': '<YOUR_VAULT_ID>',  # Replace with your vault ID
-            'cluster_id': '<YOUR_CLUSTER_ID>',  # Replace with your cluster ID
-            'env': Env.PROD,  # Deployment environment
-            'credentials': credentials
-        }
-
-        # Step 3: Configure & Initialize Skyflow Client
-        skyflow_client = (
-            Skyflow.builder()
-            .add_vault_config(vault_config)
-            .set_log_level(LogLevel.ERROR)
-            .build()
-        )
-
-        # Step 4: Prepare Sample Redacted Text
-        redacted_text = "<REDACTED_TEXT_TO_REIDENTIFY>"  # Replace with your redacted text
-
-        # Step 5: Create Reidentify Request
-        reidentify_request = ReidentifyTextRequest(
-            text=redacted_text,
-            plain_text_entities=[DetectEntities.PHONE_NUMBER]
-        )
-
-        # Step 6: Perform Text Reidentification
-        response = skyflow_client.detect().reidentify_text(reidentify_request)
-
-        # Step 7: Handle Successful Response
-        print("\nReidentify Text Response:", response)
-
-    except SkyflowError as error:
-        # Handle Skyflow-specific errors
-        print('\nSkyflow Error:', {
-            'http_code': error.http_code,
-            'grpc_code': error.grpc_code,
-            'http_status': error.http_status,
-            'message': error.message,
-            'details': error.details
-        })
-    except Exception as error:
-        # Handle unexpected errors
-        print('Unexpected Error:', error)