Server definition

Hash: sha256:b83b395eb3bc96b2b17faf388e120fc238a20c8fd087a7237dc995407a72e051
What it is: What a remote MCP server returned when asked what it offers: 6 tools

The blob, as servednamed by its sha256

{
  "instructions": "Paid tools are called directly, and there are two ways to pay for one. Anonymously: an unpaid call answers with an x402 payment challenge, and paying it (an x402-aware MCP client does this for you) accepts the job. Or from an account: if this client is connected to an ffpipe account, calls are funded from that account's credit balance instead - no challenge is presented, get_balance (free) reports what is left and what each operation costs in credits, and an account that is short is told the shortfall and where to top up rather than charged silently. Either way acceptance returns { jobId, statusUrl } for an asynchronous job. The \"t\" query parameter inside statusUrl is the ONLY proof that you own that job, so keep the whole URL: poll get_job_status with the jobId and that token until the status is finished or error, then download resultUrl within 24 hours of completion. A frame-extraction result is a MANIFEST rather than one file: download resultUrl, then fetch the url on each frame entry it lists (same window, same free re-download). If a job you paid for fails on our side you are compensated automatically: its status carries a retryVoucher - pass it as the retryVoucher input of the same tool to run the job again for free - and a job funded with credits has them refunded. If the operation you actually needed is not among these tools, call leave_feedback (free) and say so before you go - those requests are what decide which capabilities get built next.",
  "tools": [
    {
      "description": "Queue an asynchronous video conversion: fetches sourceUrl (or, with upload: true, waits for you to PUT the bytes to the returned uploadUrl), converts to MP4 scaled to fit maxWidth x maxHeight (defaults 1920x1080, cap 4096). Returns { jobId, status: \"queued\" | \"awaiting_upload\", statusUrl, uploadUrl?, uploadExpiresAt? } - poll with get_job_status (jobId + the t token from statusUrl) until finished/error. Download results within 24 hours. Paid: $0.02 USDC via x402 (base mainnet), or a convert-kind retryVoucher.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "maxHeight": {
            "description": "Max output height, default 1080",
            "maximum": 4096,
            "minimum": 1,
            "type": "integer"
          },
          "maxWidth": {
            "description": "Max output width, default 1920",
            "maximum": 4096,
            "minimum": 1,
            "type": "integer"
          },
          "retryVoucher": {
            "description": "Retry-voucher credential (`uuid.hmac`) from a failed paid job's status - pays for this call instead of x402. Single use, kind-matched.",
            "type": "string"
          },
          "sourceUrl": {
            "description": "https URL of the input media (<= 100 MiB). Fetched from datacenter IP ranges - prefer a presigned URL from storage you control; no IP literals, no localhost/.internal/.local. Provide EXACTLY ONE of sourceUrl or upload.",
            "type": "string"
          },
          "upload": {
            "const": true,
            "description": "Set true to upload the bytes yourself instead of giving a sourceUrl (exactly one of the two). The paid result then returns status awaiting_upload plus uploadUrl and uploadExpiresAt: HTTP PUT the raw bytes to uploadUrl before the deadline (201 -> queued). You are charged at acceptance; an abandoned upload window errors with no refund, while a pipeline failure after your upload earns a retryVoucher.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "name": "convert_video",
      "outputSchema": null
    },
    {
      "description": "Queue an asynchronous frame extraction - the tool to reach for when you need to SEE a video: fetches sourceUrl (or, with upload: true, waits for you to PUT the bytes to the returned uploadUrl) and extracts still frames as jpeg, webp or png. mode is REQUIRED and picks the sampling (all, every_nth, interval, keyframes, evenly_spaced, timestamps); there is no default because every candidate implies a rate you did not ask for. A finished job's resultUrl is a JSON MANIFEST: source display dimensions, fps, rotation, an echo of your parameters, frame_count, and one entry per frame with index, pts_time (seconds in the source) and its own download url on this gateway - fetch the manifest, then the frames you want. Need just ONE frame at a moment - a thumbnail, poster frame or screenshot at a given second? Use mode \"timestamps\" with a single value, e.g. timestamps=[5], format=jpeg; the result is still a one-entry manifest pointing at that image (if you would rather have the image bytes returned directly instead of via a manifest, tell us with leave_feedback - demand decides whether we add it). Up to 1000 frames per job; \"all\"/\"interval\" on a long source can exceed that and fail fast, so prefer interval, evenly_spaced or timestamps. Unreadable input, audio-only files and still images FAIL here (probe_media diagnoses those). Download within 24 hours. Paid: $0.01 USDC via x402 (base mainnet), or a frames-kind retryVoucher.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "count": {
            "description": "evenly_spaced only: how many frames to spread across the window.",
            "maximum": 1000,
            "minimum": 1,
            "type": "integer"
          },
          "endTime": {
            "description": "Window end in seconds (0 or omitted = to the end); must exceed startTime.",
            "minimum": 0,
            "type": "number"
          },
          "format": {
            "description": "Image format of each frame, default jpeg (small and accepted by every vision API). png is lossless.",
            "enum": [
              "jpeg",
              "jpg",
              "webp",
              "png"
            ],
            "type": "string"
          },
          "fps": {
            "description": "interval only: frames per second, may be below 1 (0.5 = one frame every two seconds).",
            "exclusiveMinimum": 0,
            "maximum": 120,
            "type": "number"
          },
          "maxFrames": {
            "description": "Ceiling on frames produced, default and hard limit 1000. A request whose sampling would exceed it fails before any decoding.",
            "maximum": 1000,
            "minimum": 1,
            "type": "integer"
          },
          "maxOutputHeight": {
            "description": "Fit box height, same rules as maxOutputWidth.",
            "maximum": 4096,
            "minimum": 0,
            "type": "integer"
          },
          "maxOutputWidth": {
            "description": "Fit box width applied to the source's DISPLAY dimensions: aspect preserved, never upscaled, oriented to the input. 0 = no limit on this axis.",
            "maximum": 4096,
            "minimum": 0,
            "type": "integer"
          },
          "mode": {
            "description": "How to pick frames (required): \"all\" every frame; \"every_nth\" every Nth decoded frame (needs n); \"interval\" a fixed rate in seconds (needs fps, may be below 1); \"keyframes\" keyframes only, cheap on long sources; \"evenly_spaced\" count samples across the window (needs count); \"timestamps\" one frame per given second (needs timestamps).",
            "enum": [
              "all",
              "every_nth",
              "interval",
              "keyframes",
              "evenly_spaced",
              "timestamps"
            ],
            "type": "string"
          },
          "n": {
            "description": "every_nth only: keep every Nth DECODED frame (a frame index, not a time).",
            "maximum": 9007199254740991,
            "minimum": 1,
            "type": "integer"
          },
          "quality": {
            "description": "Encoder quality for jpeg/webp, default 85; ignored for png.",
            "maximum": 100,
            "minimum": 1,
            "type": "integer"
          },
          "retryVoucher": {
            "description": "Retry-voucher credential (`uuid.hmac`) from a failed paid job's status - pays for this call instead of x402. Single use, kind-matched.",
            "type": "string"
          },
          "sourceUrl": {
            "description": "https URL of the input media (<= 100 MiB). Fetched from datacenter IP ranges - prefer a presigned URL from storage you control; no IP literals, no localhost/.internal/.local. Provide EXACTLY ONE of sourceUrl or upload.",
            "type": "string"
          },
          "startTime": {
            "description": "Window start in seconds (default 0).",
            "minimum": 0,
            "type": "number"
          },
          "timestamps": {
            "description": "timestamps only: seconds into the source, one accurate frame each. Sorted for you.",
            "items": {
              "minimum": 0,
              "type": "number"
            },
            "maxItems": 1000,
            "type": "array"
          },
          "upload": {
            "const": true,
            "description": "Set true to upload the bytes yourself instead of giving a sourceUrl (exactly one of the two). The paid result then returns status awaiting_upload plus uploadUrl and uploadExpiresAt: HTTP PUT the raw bytes to uploadUrl before the deadline (201 -> queued). You are charged at acceptance; an abandoned upload window errors with no refund, while a pipeline failure after your upload earns a retryVoucher.",
            "type": "boolean"
          }
        },
        "required": [
          "mode"
        ],
        "type": "object"
      },
      "name": "extract_frames",
      "outputSchema": null
    },
    {
      "description": "Free. Reports the credit balance of the account this client is connected to, plus what one credit is worth, what each operation costs in credits, the monthly free allowance and whether a card is on file to unlock it. Takes no input: it reads the account behind the credential your client already connected with. If you have a connected account, paid tools are funded from this balance and never present a payment challenge - so call this to find out how much work you can still queue, and top up at the account page named in the answer. Anonymous callers (x402 buyers, who pay per call instead) have no balance and get an unauthorized error; either way nothing here is charged.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "get_balance",
      "outputSchema": null
    },
    {
      "description": "Free status lookup for a job accepted by convert_video / probe_media / extract_frames. Requires the job's ownership token - the `t` query parameter of the statusUrl returned at acceptance (store the whole statusUrl; it cannot be regenerated). Status goes [awaiting_upload ->] queued -> finished | error; awaiting_upload jobs report uploadExpiresAt but NEVER the uploadUrl (that credential is handed out exactly once, in the acceptance result); finished jobs carry resultUrl/thumbnailUrl/durationMs (always served by this gateway, never a redirect; free to re-download within 24 hours of completion); a failed charged job (including one that could not be queued after payment) carries retryVoucher. A bad token and an unknown jobId both answer not_found, deliberately.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "jobId": {
            "description": "Job id from the acceptance",
            "type": "string"
          },
          "token": {
            "description": "Ownership token - the `t` query parameter of statusUrl",
            "type": "string"
          }
        },
        "required": [
          "jobId",
          "token"
        ],
        "type": "object"
      },
      "name": "get_job_status",
      "outputSchema": null
    },
    {
      "description": "Tell us what you needed. If ffpipe does not offer the operation you came for - another output format, extracting a frame, a different transformation entirely - say so here: these requests are aggregated and they drive directly what gets built next, so a one-line \"I wanted X\" is genuinely useful to us. Also the place for bug reports and any other feedback. Free, unauthenticated, and one-way: nothing is returned but an acknowledgement, and no job is created. Include jobId if a specific job prompted this (context only - it is not checked and is not required), and contact if you want a reply. Message limit 2000 characters.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "contact": {
            "description": "Optional. An email or handle to reply at, up to 200 characters. Omit it and the submission stays anonymous.",
            "maxLength": 200,
            "type": "string"
          },
          "jobId": {
            "description": "Optional job id this relates to. Context only - ownership is NOT checked and no token is needed.",
            "type": "string"
          },
          "message": {
            "description": "What you wanted, what went wrong, or what you think. Plain text, 1 to 2000 characters. Be concrete: \"needed a single frame as a jpeg at a given timestamp\" is worth more to us than \"more features\".",
            "maxLength": 2000,
            "minLength": 1,
            "type": "string"
          },
          "type": {
            "description": "What this is: \"feature_request\" for a capability ffpipe does not offer yet, \"bug\" for something broken, \"feedback\" for anything else. Defaults to \"feedback\".",
            "enum": [
              "feature_request",
              "bug",
              "feedback"
            ],
            "type": "string"
          }
        },
        "required": [
          "message"
        ],
        "type": "object"
      },
      "name": "leave_feedback",
      "outputSchema": null
    },
    {
      "description": "Queue an asynchronous media inspection: fetches sourceUrl (or, with upload: true, waits for you to PUT the bytes to the returned uploadUrl) and returns its technical metadata as a downloadable file. In the default json format the result is the full raw analysis plus one added top-level \"ffpipe_summary\" object: container, duration_s, size_bytes, has_video, has_audio, video_codec, audio_codec, coded_width/height, display_width/height, rotation, fps, is_hdr, audio_channels, audio_sample_rate. USE display_width/display_height as the size the picture actually is - phones store portrait video as a landscape frame plus a rotation flag. A file that cannot be decoded is still a SUCCESS whose result carries the diagnosis. Returns { jobId, status, statusUrl, ... } - poll with get_job_status until finished/error, then download resultUrl within 24 hours. Paid: $0.01 USDC via x402 (base mainnet), or a probe-kind retryVoucher.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {
          "countFrames": {
            "description": "Count frames exactly. Requires decoding the whole file - slow on long sources.",
            "type": "boolean"
          },
          "countPackets": {
            "description": "Count packets exactly. Same cost caveat as countFrames.",
            "type": "boolean"
          },
          "outputFormat": {
            "description": "Format of the delivered analysis, default json. Only json carries the ffpipe_summary block; the rest are raw. flat is delivered as .txt.",
            "enum": [
              "json",
              "xml",
              "csv",
              "flat",
              "ini"
            ],
            "type": "string"
          },
          "readIntervals": {
            "description": "Limit the analysis to a window, e.g. \"%+60\" (first 60 seconds), \"30%+10\" (10 seconds from 0:30), \"%+#500\" (first 500 packets).",
            "maxLength": 256,
            "type": "string"
          },
          "retryVoucher": {
            "description": "Retry-voucher credential (`uuid.hmac`) from a failed paid job's status - pays for this call instead of x402. Single use, kind-matched.",
            "type": "string"
          },
          "sections": {
            "description": "Which sections to report. Default: format, streams, chapters.",
            "items": {
              "enum": [
                "format",
                "streams",
                "chapters",
                "programs"
              ],
              "type": "string"
            },
            "type": "array"
          },
          "selectStreams": {
            "description": "Restrict the analysis to matching streams, e.g. \"v:0\" (first video stream) or \"a\" (all audio).",
            "maxLength": 256,
            "type": "string"
          },
          "showEntries": {
            "description": "Keep only the named fields, e.g. \"frame=pict_type,pts_time,key_frame\" or \"format=duration\". Section and field names only.",
            "maxLength": 256,
            "type": "string"
          },
          "showFrames": {
            "description": "Report per-FRAME detail. Large: a bounded window is applied for you unless you send readIntervals. Pair with showEntries to keep only the fields you need.",
            "type": "boolean"
          },
          "showPackets": {
            "description": "Report per-PACKET detail. Same bounded-window treatment as showFrames.",
            "type": "boolean"
          },
          "sourceUrl": {
            "description": "https URL of the input media (<= 100 MiB). Fetched from datacenter IP ranges - prefer a presigned URL from storage you control; no IP literals, no localhost/.internal/.local. Provide EXACTLY ONE of sourceUrl or upload.",
            "type": "string"
          },
          "summary": {
            "description": "Keep the normalized ffpipe_summary block (json only). Default true; send false for byte-exact raw output.",
            "type": "boolean"
          },
          "upload": {
            "const": true,
            "description": "Set true to upload the bytes yourself instead of giving a sourceUrl (exactly one of the two). The paid result then returns status awaiting_upload plus uploadUrl and uploadExpiresAt: HTTP PUT the raw bytes to uploadUrl before the deadline (201 -> queued). You are charged at acceptance; an abandoned upload window errors with no refund, while a pipeline failure after your upload earns a retryVoucher.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "name": "probe_media",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:b83b395eb3bc96b2b17faf388e120fc238a20c8fd087a7237dc995407a72e051 | sha256sum