## Create Verify Job

`client.Alpha.Verify.New(ctx, params) (*AlphaVerifyNewResponse, error)`

**post** `/api/alpha/verify`

Create a Verify job.

Analyzes a document for signs of doctoring (splicing, copy-move,
AI generation, metadata tampering, ...). Set `file_input` to a
file ID (`dfl-...`). Optionally provide a `configuration` object
to control the semantic agent.

The job runs asynchronously. Poll `GET /verify/{job_id}`
with `expand=result` to check status and retrieve results.

### Parameters

- `params AlphaVerifyNewParams`

  - `OrganizationID param.Field[string]`

    Query param

  - `ProjectID param.Field[string]`

    Query param

  - `Configuration param.Field[AlphaVerifyNewParamsConfiguration]`

    Body param: Configuration for a Verify job.

    - `TargetPages string`

      Comma-separated page numbers or ranges to analyze (1-based). Omit to analyze all pages. Ignored for non-PDF inputs.

    - `Tier string`

      Verify tier: 'fast' runs only the quick deterministic forensic checks (metadata, content integrity, container structure, pixel statistics); 'agentic' (default) runs the full pipeline including the learned detectors and the semantic review pass.

      - `const AlphaVerifyNewParamsConfigurationTierAgentic AlphaVerifyNewParamsConfigurationTier = "agentic"`

      - `const AlphaVerifyNewParamsConfigurationTierFast AlphaVerifyNewParamsConfigurationTier = "fast"`

  - `FileID param.Field[string]`

    Body param: Deprecated: use file_input instead

  - `FileInput param.Field[string]`

    Body param: File ID of the document to analyze

  - `TransactionID param.Field[string]`

    Body param: Idempotency key scoped to the project. Reusing a key returns the original job; the new request body is ignored.

  - `WebhookConfigurationIDs param.Field[[]string]`

    Body param: IDs of saved webhook configurations to notify for this job.

  - `WebhookConfigurations param.Field[[]AlphaVerifyNewParamsWebhookConfiguration]`

    Body param: Outbound webhook endpoints to notify on job status changes

    - `WebhookEvents []string`

      Events to subscribe to (e.g. 'parse.success', 'extract.error'). If null, all events are delivered.

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventBatchCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "batch.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventBatchError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "batch.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventBatchPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "batch.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventBatchRunning AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "batch.running"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventBatchSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "batch.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifyCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifyError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifyPartialSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.partial_success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifyPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifyRunning AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.running"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventClassifySuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "classify.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventExtractCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "extract.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventExtractError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "extract.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventExtractPartialSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "extract.partial_success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventExtractPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "extract.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventExtractSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "extract.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParseCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParseError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParsePartialSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.partial_success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParsePending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParseRunning AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.running"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventParseSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "parse.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSheetsCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "sheets.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSheetsError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "sheets.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSheetsPartialSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "sheets.partial_success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSheetsPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "sheets.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSheetsSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "sheets.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSplitCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "split.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSplitError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "split.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSplitPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "split.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSplitProcessing AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "split.processing"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventSplitSuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "split.success"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventUnmappedEvent AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "unmapped_event"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventVerifyCancelled AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "verify.cancelled"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventVerifyError AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "verify.error"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventVerifyPending AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "verify.pending"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventVerifyRunning AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "verify.running"`

      - `const AlphaVerifyNewParamsWebhookConfigurationWebhookEventVerifySuccess AlphaVerifyNewParamsWebhookConfigurationWebhookEvent = "verify.success"`

    - `WebhookHeaders map[string, string]`

      Custom HTTP headers sent with each webhook request (e.g. auth tokens)

    - `WebhookOutputFormat string`

      Response format sent to the webhook: 'string' (default) or 'json'

    - `WebhookSigningSecret string`

      Shared signing secret used to sign webhook deliveries. When set, each request includes an HMAC-SHA256 signature of the request body in the 'LC-Signature' header (value 'sha256=<hex>'). Recompute the HMAC over the raw request body with this secret to verify the delivery is authentic.

    - `WebhookURL string`

      URL to receive webhook POST notifications

### Returns

- `type AlphaVerifyNewResponse struct{…}`

  Response for a Verify job.

  - `ID string`

    Unique identifier

  - `Configuration AlphaVerifyNewResponseConfiguration`

    Verify configuration used for this job

    - `TargetPages string`

      Comma-separated page numbers or ranges to analyze (1-based). Omit to analyze all pages. Ignored for non-PDF inputs.

    - `Tier string`

      Verify tier: 'fast' runs only the quick deterministic forensic checks (metadata, content integrity, container structure, pixel statistics); 'agentic' (default) runs the full pipeline including the learned detectors and the semantic review pass.

      - `const AlphaVerifyNewResponseConfigurationTierAgentic AlphaVerifyNewResponseConfigurationTier = "agentic"`

      - `const AlphaVerifyNewResponseConfigurationTierFast AlphaVerifyNewResponseConfigurationTier = "fast"`

  - `DocumentInputType AlphaVerifyNewResponseDocumentInputType`

    Type of the document input (FILE)

    - `const AlphaVerifyNewResponseDocumentInputTypeFileID AlphaVerifyNewResponseDocumentInputType = "file_id"`

    - `const AlphaVerifyNewResponseDocumentInputTypeParseJobID AlphaVerifyNewResponseDocumentInputType = "parse_job_id"`

    - `const AlphaVerifyNewResponseDocumentInputTypeURL AlphaVerifyNewResponseDocumentInputType = "url"`

  - `FileInput string`

    ID of the input file

  - `ProjectID string`

    Project this job belongs to

  - `Status AlphaVerifyNewResponseStatus`

    Current job status: PENDING, RUNNING, COMPLETED, FAILED, or CANCELLED

    - `const AlphaVerifyNewResponseStatusCancelled AlphaVerifyNewResponseStatus = "CANCELLED"`

    - `const AlphaVerifyNewResponseStatusCompleted AlphaVerifyNewResponseStatus = "COMPLETED"`

    - `const AlphaVerifyNewResponseStatusFailed AlphaVerifyNewResponseStatus = "FAILED"`

    - `const AlphaVerifyNewResponseStatusPending AlphaVerifyNewResponseStatus = "PENDING"`

    - `const AlphaVerifyNewResponseStatusRunning AlphaVerifyNewResponseStatus = "RUNNING"`

  - `UserID string`

    User who created this job

  - `CreatedAt Time`

    Creation datetime

  - `ErrorMessage string`

    Error message if job failed

  - `Result AlphaVerifyNewResponseResult`

    Result of a Verify (doctored-document) analysis.

    Raw per-signal detail (evidence list, per-family sub-scores, raw regions,
    forensic heatmaps) is available separately via the job's details endpoint.

    - `DetectorVersion string`

      Version of the detector that produced the result

    - `OverallScore float64`

      Overall doctoring likelihood (0 to 1)

    - `Verdict string`

      Overall verdict for the document

      - `const AlphaVerifyNewResponseResultVerdictAuthentic AlphaVerifyNewResponseResultVerdict = "AUTHENTIC"`

      - `const AlphaVerifyNewResponseResultVerdictDoctored AlphaVerifyNewResponseResultVerdict = "DOCTORED"`

      - `const AlphaVerifyNewResponseResultVerdictLikelyDoctored AlphaVerifyNewResponseResultVerdict = "LIKELY_DOCTORED"`

      - `const AlphaVerifyNewResponseResultVerdictNoStrongSignal AlphaVerifyNewResponseResultVerdict = "NO_STRONG_SIGNAL"`

      - `const AlphaVerifyNewResponseResultVerdictSuspicious AlphaVerifyNewResponseResultVerdict = "SUSPICIOUS"`

    - `CompositeScores AlphaVerifyNewResponseResultCompositeScores`

      Composite scores, each answering one question about the document

      - `AIGenerated AlphaVerifyNewResponseResultCompositeScoresAIGenerated`

        Was this content synthesized by a generative model?

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

      - `DocumentCoherence AlphaVerifyNewResponseResultCompositeScoresDocumentCoherence`

        Does the document's content agree with itself (checksums, arithmetic, machine-readable zones)?

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

      - `DocumentMetadata AlphaVerifyNewResponseResultCompositeScoresDocumentMetadata`

        Does the file's provenance / toolchain history look suspicious? Advisory: individually weak workflow-hygiene signals

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

      - `KnownFraud AlphaVerifyNewResponseResultCompositeScoresKnownFraud`

        Has this asset (or its template) been seen in fraud before?

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

      - `ManuallyEdited AlphaVerifyNewResponseResultCompositeScoresManuallyEdited`

        Was this document altered after creation (splice, retype, redact, inpaint)?

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

      - `Recapture AlphaVerifyNewResponseResultCompositeScoresRecapture`

        Was the document captured through a channel that destroys forensic evidence (photo of a screen, print-then-rescan)?

        - `Applicable bool`

          Whether the checks feeding this composite ran on this document. When false the document was not checked for this — not cleared of it

        - `Score float64`

          Score (0 to 1); null when the composite was not applicable

    - `Confidence float64`

      Confidence in the verdict (0 to 1): how firmly the detected signals support the verdict bucket, independent of the doctoring likelihood itself

    - `Error string`

      Error detail when the analysis could not complete

    - `PageCount int64`

      Number of analysed pages (1 for images/docx)

    - `PageDimensions []AlphaVerifyNewResponseResultPageDimension`

      Rendered pixel size per page, so region bboxes can be scaled onto the page

      - `Height int64`

        Rendered page height in pixels

      - `Page int64`

        0-based page index (0 for standalone images)

      - `Width int64`

        Rendered page width in pixels

    - `Reasoning string`

      Explanation of the verdict

    - `SuspectRegions []AlphaVerifyNewResponseResultSuspectRegion`

      Regions that led to the suspected fraud, ranked most-suspect first, each with an explanation of what makes it suspect

      - `Bbox []int64`

        Region bounding box as [x, y, w, h] in page-render pixels

      - `Explanation string`

        Human-readable explanation of what makes this region suspect

      - `Kind string`

        Kind of anomaly detected in this region

      - `Page int64`

        0-based page index (0 for standalone images)

      - `Score float64`

        Suspicion score for this region (0 to 1)

      - `Source string`

        Detector that flagged this region

      - `Primary bool`

        Whether this region is part of the small set of decisive evidence behind the verdict — the boxes a reviewer should look at first

      - `Review string`

        Automated reviewer verdict for this region (confirmed, dismissed, unsure, or empty). A dismissed region can still be surfaced when it is the only place to look; this label says how to read it

    - `SyntheticScore float64`

      Likelihood (0 to 1) that the document is wholly generated or fabricated rather than a capture of a real document. Null for jobs completed before this score was introduced

    - `TamperingScore float64`

      Likelihood (0 to 1) that a real captured document was locally edited — a genuine capture with regions altered after the fact. Null for jobs completed before this score was introduced

  - `TransactionID string`

    Idempotency key

  - `UpdatedAt Time`

    Update datetime

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/run-llama/llama-parse-go"
  "github.com/run-llama/llama-parse-go/option"
)

func main() {
  client := llamacloud.NewClient(
    option.WithAPIKey("My API Key"),
  )
  verify, err := client.Alpha.Verify.New(context.TODO(), llamacloud.AlphaVerifyNewParams{

  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", verify.ID)
}
```

#### Response

```json
{
  "id": "id",
  "configuration": {
    "target_pages": "1,3,5-7",
    "tier": "agentic"
  },
  "document_input_type": "file_id",
  "file_input": "file_input",
  "project_id": "project_id",
  "status": "CANCELLED",
  "user_id": "user_id",
  "created_at": "2019-12-27T18:11:19.117Z",
  "error_message": "error_message",
  "result": {
    "detector_version": "detector_version",
    "overall_score": 0,
    "verdict": "AUTHENTIC",
    "composite_scores": {
      "ai_generated": {
        "applicable": true,
        "score": 0
      },
      "document_coherence": {
        "applicable": true,
        "score": 0
      },
      "document_metadata": {
        "applicable": true,
        "score": 0
      },
      "known_fraud": {
        "applicable": true,
        "score": 0
      },
      "manually_edited": {
        "applicable": true,
        "score": 0
      },
      "recapture": {
        "applicable": true,
        "score": 0
      }
    },
    "confidence": 0,
    "error": "error",
    "page_count": 1,
    "page_dimensions": [
      {
        "height": 0,
        "page": 0,
        "width": 0
      }
    ],
    "reasoning": "reasoning",
    "suspect_regions": [
      {
        "bbox": [
          0,
          0,
          0,
          0
        ],
        "explanation": "explanation",
        "kind": "kind",
        "page": 0,
        "score": 0,
        "source": "source",
        "primary": true,
        "review": "review"
      }
    ],
    "synthetic_score": 0,
    "tampering_score": 0
  },
  "transaction_id": "transaction_id",
  "updated_at": "2019-12-27T18:11:19.117Z"
}
```
