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

# Resume Scanner



## OpenAPI

````yaml /openapi.yaml post /scanners/{scanner_uid}/resume
openapi: 3.1.0
info:
  title: OathNet Service API
  version: 2.0.0
  description: >
    # OathNet Service API Documentation


    Welcome to the OathNet Service API. This API provides breach search, stealer
    search,

    victims exploration, file search, exports, bulk search, scanners, and OSINT
    enrichment.


    ## Authentication


    Most `/api/service/*` endpoints require authentication via API key. Include
    your API key

    in the `x-api-key` header.


    ```

    x-api-key: YOUR_API_KEY

    ```


    You can obtain an API key from your dashboard at
    https://oathnet.org/dashboard?tab=account


    ## Rate Limiting & Quotas


    - Each request consumes from your daily lookup quota

    - Quota limits depend on your subscription plan

    - The `_meta.lookups` object in responses shows remaining daily lookups

    - Service-specific quotas may apply to certain endpoints


    ## Search Sessions


    For optimal quota management, initialize a search session before making
    service calls:

    1. Call `/service/search/init` with your query

    2. Use the returned `session.id` as `search_id` in subsequent service calls

    3. This groups related lookups and provides better quota tracking


    ## Structured Filters


    V2 search endpoints share one structured filter contract:


    - use `GET` for simple searches and URL-friendly flat filters

    - use `POST` on the same search route when you have an AI/manual structured
    filter, a saved `filter_id`, or a filter tree that is awkward to URL-encode

    - `filter` is a JSON-encoded filter tree on query-string endpoints and a
    real JSON object on POST endpoints

    - POST search routes still take pagination, sorting, date range, `view`, and
    `search_id` as query parameters; the JSON body is for `filter` and
    `filter_id`

    - `filter_id` is a 24-character transient context ID returned by the AI
    filter flow or prior searches

    - explicit `filter` overrides a stored `filter_id` context, and flat params
    may still be used in the same request

    - the same filter objects are reused by AI filter responses, exports, bulk
    search, and scanners

    - advanced filters use leaf rules with `field`, `operator`, and `value`,
    plus `and` / `or` groups for boolean logic

    - supported operators are `eq`, `neq`, `contains`, `starts_with`,
    `ends_with`, `wildcard`, `gt`, `gte`, `lt`, `lte`, `exists`, `in`, and
    `not_in`


    See the `StructuredFilterNode` schema and `/guides/structured-filters` for
    the full operator list and examples.


    ## Success Response Patterns


    Successful responses use three main patterns:


    - Envelope JSON:
      Common on search-session and OSINT endpoints, plus `v2/stealer/search`,
      `v2/breach/search`, `v2/victims/search`, `v2/stealer/subdomain`,
      and `v2/bulk-search` create.
    - Raw JSON:
      Common on `v2/breach/autocomplete*`, `v2/ai/filter*`,
      `v2/files/search`, `v2/victims/*/properties`, `v2/victims/*/summary`,
      `v2/file-search*`, `v2/exports*`, `v2/bulk-search` list and status,
      `v2/victims/{log_id}`, `v2/phonebook`, and most scanner endpoints.
    - File or text stream:
      Victim file downloads, victim archive downloads, export downloads,
      and bulk-search downloads.

    ## Error Handling


    API-generated errors generally return with `success: false` and include:

    - `message`: Human-readable error description

    - `errors`: Object with field-specific or general error details


    Common HTTP status codes:

    - `200`: Success

    - `202`: Async job accepted

    - `400`: Bad Request (invalid parameters)

    - `401`: Unauthorized (missing or invalid token)

    - `403`: Forbidden (Cloudflare block or quota exceeded)

    - `404`: Not Found

    - `409`: Conflict

    - `429`: Too Many Requests

    - `500`: Internal Server Error

    - `502`: Bad Gateway

    - `503`: Service Unavailable
  contact:
    name: OathNet Support
    url: https://oathnet.org/support
  license:
    name: Proprietary
    url: https://oathnet.org/terms
servers:
  - url: https://oathnet.org/api
    description: Production API Server
security:
  - ApiKeyAuth: []
tags:
  - name: Search Session
    description: Initialize and manage search sessions for grouped lookups
  - name: Breach Search
    description: Search across breach databases for leaked credentials and data
  - name: Stealer Search
    description: Original stealer search route for simple credential lookups
  - name: V2 Stealer
    description: Enhanced V2 stealer search with advanced filtering and pagination
  - name: V2 Investigation
    description: >-
      Multi-section investigation across credentials, victims, evidence, files,
      and related credentials
  - name: V2 Breach
    description: Current breach search, autocomplete, and filter workflows
  - name: V2 Victims
    description: Search and explore victim profiles and their associated files
  - name: V2 File Search
    description: Search within victim files using regex, literal, or wildcard patterns
  - name: V2 File Metadata
    description: Search victim file metadata without fetching file bytes
  - name: V2 Export
    description: Export search results to JSONL or CSV format
  - name: V2 Bulk Search
    description: Batch many terms into an asynchronous export-style search job
  - name: Scanners
    description: >-
      Automated monitoring and delivery management for stealer and breach
      scanners
  - name: OSINT Lookups
    description: Open Source Intelligence lookups for various platforms
  - name: Utility
    description: Utility endpoints for autocomplete and other helpers
paths:
  /scanners/{scanner_uid}/resume:
    post:
      tags:
        - Scanners
      summary: Resume Scanner
      operationId: resumeScanner
      parameters:
        - name: scanner_uid
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Raw scanner object
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Scanner'
components:
  schemas:
    Scanner:
      type: object
      properties:
        uid:
          type: string
        user:
          type: string
        name:
          type: string
        scanner_type:
          type: string
          enum:
            - stealer
            - breach
        scanner_type_display:
          type: string
        status:
          type: string
          enum:
            - active
            - paused
            - disabled
        status_display:
          type: string
        query_config:
          $ref: '#/components/schemas/ScannerQueryConfig'
        notification_type:
          type: string
          enum:
            - email
            - webhook
            - discord
        notification_type_display:
          type: string
        webhook_url:
          type: string
          nullable: true
        webhook_security_mode:
          type: string
          description: >-
            `api_key` is only available on existing scanners. New webhook
            scanners should use `signed_json` or `signed_encrypted`.
          enum:
            - api_key
            - signed_json
            - signed_encrypted
        webhook_secret_last_rotated_at:
          type: string
          format: date-time
          nullable: true
        notify_on_zero_results:
          type: boolean
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
        last_run_at:
          type: string
          format: date-time
          nullable: true
        last_found_at:
          type: string
          format: date-time
          nullable: true
        next_run_at:
          type: string
          format: date-time
          nullable: true
        total_results_found:
          type: integer
        total_runs:
          type: integer
        consecutive_failures:
          type: integer
    ScannerQueryConfig:
      allOf:
        - $ref: '#/components/schemas/SearchQueryConfig'
        - type: object
          description: >
            Persistent scanner search definition.


            Scanners reuse the same flat filters and structured `filter` grammar
            as V2 search,

            but reject runtime-only params such as `from`, `to`, `cursor`,
            `page_size`, `format`,

            `debug`, and `search_id`. Scanner runs always execute on
            `indexed_at`.
          properties:
            extra_params:
              type: object
              description: >-
                Optional extra scalar query params merged into execution
                requests.
              additionalProperties:
                $ref: '#/components/schemas/JsonScalarOrArray'
    SearchQueryConfig:
      type: object
      description: >
        Reusable JSON form of a search request for exports and bulk-search jobs.


        It accepts the same public filter keys as the corresponding V2 search
        endpoint, plus `filter`

        and `filter_id`. Prefer canonical JSON keys such as `domain`,
        `email_domain`, `dbname`,

        and `username`; bracketed variants such as `domain[]` are also accepted
        by the API.
      example:
        q: alice@example.com
        email: alice@example.com
        dbname[]:
          - linkedin.com
          - twitter.com
        wildcard: true
        extra_params:
          sort: '-indexed_at'
      properties:
        q:
          type: string
        filter:
          $ref: '#/components/schemas/StructuredFilterNode'
        filter_id:
          $ref: '#/components/schemas/FilterContextId'
        wildcard:
          type: boolean
        logic:
          type: string
          enum:
            - and
            - or
        from:
          type: string
          format: date-time
        to:
          type: string
          format: date-time
        date_field:
          type: string
          enum:
            - indexed_at
            - pwned_at
        sort:
          type: string
      additionalProperties:
        $ref: '#/components/schemas/JsonScalarOrArray'
    JsonScalarOrArray:
      description: A scalar value or an array of scalar values.
      oneOf:
        - type: string
        - type: number
        - type: boolean
        - type: array
          items:
            oneOf:
              - type: string
              - type: number
              - type: boolean
    StructuredFilterNode:
      description: |
        Recursive structured filter tree.

        Constraints:
        - maximum nesting depth: 2
        - maximum leaf conditions: 50
        - each node should use exactly one of `field`, `and`, or `or`
      oneOf:
        - $ref: '#/components/schemas/StructuredFilterLeafNode'
        - $ref: '#/components/schemas/StructuredFilterAndNode'
        - $ref: '#/components/schemas/StructuredFilterOrNode'
    FilterContextId:
      type: string
      description: 24-character transient filter context ID.
      pattern: ^[0-9a-fA-F]{24}$
      example: 0123456789abcdef01234567
    StructuredFilterLeafNode:
      type: object
      description: Leaf rule for one field.
      required:
        - field
        - operator
      properties:
        field:
          type: string
          description: Public field name accepted by the selected endpoint.
          example: country
        operator:
          $ref: '#/components/schemas/FilterOperator'
        value:
          $ref: '#/components/schemas/StructuredFilterValue'
      example:
        field: country
        operator: eq
        value: us
    StructuredFilterAndNode:
      type: object
      description: Compound node that ANDs all child rules.
      required:
        - and
      properties:
        and:
          type: array
          items:
            $ref: '#/components/schemas/StructuredFilterNode'
      example:
        and:
          - field: country
            operator: eq
            value: us
          - field: dbname
            operator: eq
            value: linkedin.com
    StructuredFilterOrNode:
      type: object
      description: Compound node that ORs all child rules.
      required:
        - or
      properties:
        or:
          type: array
          items:
            $ref: '#/components/schemas/StructuredFilterNode'
      example:
        or:
          - field: email
            operator: ends_with
            value: '@gmail.com'
          - field: email
            operator: ends_with
            value: '@outlook.com'
    FilterOperator:
      type: string
      description: |
        Structured filter operator.

        `in` and `not_in` require string arrays.
        `exists` accepts a boolean and defaults to `true` when omitted.
        All other operators expect string values.
      enum:
        - eq
        - neq
        - in
        - not_in
        - contains
        - starts_with
        - ends_with
        - gt
        - gte
        - lt
        - lte
        - exists
        - wildcard
    StructuredFilterValue:
      description: |
        Filter value payload.

        Use strings for most operators, string arrays for `in` and `not_in`,
        and booleans for `exists`.
      oneOf:
        - type: string
        - type: boolean
        - type: array
          items:
            type: string
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: API key for authentication (lowercase header name)

````