animica

Music generation, stem separation, vocal isolation, enhancement and mastering. Rendered by the Animica GPU-miner queue. Sold only while a miner for the requested kind is online — the catalog reports available:false and the endpoint answers 503 otherwise. Returns a job handle immediately (rendering is asynchronous); polling the returned poll_url is free. Kinds: audio, audio_stems, audio_isolate, audio_enhance, audio_master.

Text-to-video, image-to-video, upscale, interpolate, subtitles, background removal and shorts. Rendered by the Animica GPU-miner queue. Sold only while a miner for the requested kind is online — the catalog reports available:false and the endpoint answers 503 otherwise. Returns a job handle immediately (rendering is asynchronous); polling the returned poll_url is free. Kinds: video_t2v, video_i2v, video_multiscene, video_upscale, video_interpolate, video_subtitles, video_bgremove, video_shorts.

The ANM/USD reference price this operator actually uses, attested at a specific chain head. Quoted from the NonKYC BID (the conservative side), with the observation timestamp and feed age included so you can judge freshness yourself. NOTE: no signing key is configured on this gateway, so attestations are returned UNSIGNED (signed:false). The price is still the live one we use; it simply carries no cryptographic attestation. A stale or indicative feed makes this product unavailable rather than quoting a dead rate.

Competitive position for a single x402 resource. Give a URL that is listed anywhere in the merged index and get back what the index holds on it (including any correction our own unpaid 402 probe made to its advertised price), the peer set derived from its own description, and where it ranks among those peers on price, call volume, payer diversity and callability — plus the mirrors of itself that are listed as separate services. Useful whether the endpoint is yours or one you are about to buy from. Interpretation is written by Animica's own AICF inference network; every figure is computed in code.

Price positioning for an x402 service. Describe what you sell (and optionally what you charge) and get the comparable set — named, counted, and listed — plus your exact percentile within it, the full decile ladder of what those comparables charge, how much demand sits in each price band, and a suggested band derived from the comparables rather than asserted. Refuses to compute a percentile when too few real comparables exist, because a confident percentile over four loosely-related rows is worse than no answer. Interpretation is written by Animica's own AICF inference network; every figure is computed in code.

Statistical analysis of any segment of the x402 economy, computed over a merged index of Coinbase Bazaar and 402index overlaid with our own unpaid 402 probes. Returns the full price distribution (min, p10, p25, median, p75, p90, max, mean), demand discounted by payer concentration, what share of the segment can actually be invoked, the network and asset split, host concentration, liveness, and — once history exists — the trend. Every figure is computed in code from named rows; the interpretation is written by Animica's own AICF inference network and every sentence containing a number not in the computed facts is deleted before delivery. Directories publish rows; this publishes the distribution.

A point-in-time read of the Animica mempool and network: pending transaction count and ids, total pending bytes, the age of the oldest entry, chain head, peer count and network hashrate. What a bot watching for congestion, fee conditions or inclusion timing needs, without running a node.

Give it up to 10 URLs and get back the readable text of each — titles, clean body text, navigation and scripts removed — in a single call and a single payment. The half of every retrieval pipeline an agent already has links for: search results, a sitemap, an RSS feed, a user's reading list. Pages are fetched concurrently under a deadline. Every URL you send is accounted for: the ones that could not be read come back in failed[] WITH the reason (403, timeout, paywall, no extractable text, private address), because a bad input and a broken fetcher need opposite responses from you. If not one URL could be read, you are NOT charged.

One call that searches the web and returns the readable text of the top pages — the whole "look this up" loop an agent otherwise writes by hand as a search plus N fetches plus N HTML cleanups. Pages are fetched concurrently under a deadline, stripped of navigation and scripts, and returned with their titles and source URLs. Every page you asked for is accounted for: the ones that could not be read come back in pages_failed WITH the reason (403, timeout, paywall, no extractable text), because a thin web and a broken fetcher look identical otherwise. No model is called and nothing is summarised — you get the evidence, not an answer to trust. If the search finds nothing, or every page fails, you are NOT charged.

Search the live web and get back ranked results with titles, URLs and snippets — no account, no API key, one payment per query. Built for agents that need to look something up mid-task: results are deduplicated by URL across every engine that answered, and the engines that produced them are named in the response so you can judge the coverage you actually received rather than assuming it was complete. If no engine answers, the request fails and you are NOT charged — an empty result set is never sold as an answer.

Full-text search over what machine-payable services actually publish — their descriptions, input schemas, parameter names, prices and settlement networks — across ~18,000 x402 endpoints. Built from their own payment challenges, which a general crawler discards as a dead page: ask for a parameter name, a schema field or a network and you match services whose one-line blurb never mentions it. Filter by price ceiling, by whether the service publishes a call spec, and by payment protocol. Every response states how many documents were searched and how stale the oldest is, because an index that will not tell you its size is asking to be trusted about the one thing you cannot check. Ranked by BM25 — no model, so the same query ranks the same way twice. If the index is empty or nothing matches, you are NOT charged.

Buy this before spending money on GPUs for Animica, or when choosing which of several boxes to point here. POST an array of candidate rigs — gpu_model, hashrate_hps, power_w, cost_usd, vram_gb — and get them RANKED by net Animica return against live network state: the per-block reward from the node's own block template (not the published subsidy split, which overstates the miner's slice by 2x on mainnet), the measured block interval, live difficulty, and the ANM/USD bid. Per rig you get ANM/day, USD/day gross and NET of power, break-even electricity price, payback days from cost_usd, and USD/day per $1,000 of capital. Every rig ALSO gets its best non-PoW Animica use: which marketplace media kinds its VRAM clears (floors parsed live from the reference miner client, never remembered) crossed against a live census of how many GPU miners serve each kind — so a card that loses on hashrate can still win because it is the only supplier for a kind nobody serves. Rendering gets no USD figure on purpose: no job-arrival rate is published and inventing one would be the only fabricated number here. Deterministic, no model called, optional ML-DSA-65 attestation binding the ranking to a chain height. Node, renderer census or price feed unreachable: 503 with the reason, NOT charged.

Buy this before pointing a GPU at Animica, or when you run one and need to know whether today it should mine, render or stay off. Send gpu_model, vram_gb, count, power_w and electricity_usd_kwh; get a deterministic ranking of the workloads this network can actually use right now — proof-of-work mining, image, video, audio or idle. Mining is priced from LIVE chain state (difficulty, the observed block interval, the subsidy at the current height, the ANM/USD feed): ANM/day, USD/day gross and NET of power, the break-even electricity price, and the marginal effect of one more card — which on a capped-emission chain is frequently NEGATIVE, so eight cards can net less than one. Rendering is ranked on a live renderer census: which media kinds have ZERO GPU miners online, i.e. where you would be the only supplier. Rendering gets no dollar figure on purpose — the marketplace publishes no job-arrival rate, and inventing one would be the most useful-looking number here and the only fabricated one. No model is consulted, so the same inputs rank the same way twice. Pass already_mining:true if this rig is ALREADY on Animica, or its own work is counted in both your share and the network it is divided into. Optional ML-DSA-65 attestation binds the answer to a chain height. Unreachable node: NOT charged. Dead price feed: you still get ANM/day and the census, USD null with the reason. Renderer census down: mining is still priced and the census field says why it could not be read, which is not the same fact as zero renderers.

Live ANM monetary state from the Animica L1 itself: supply and account count, the block reward the node will actually credit (not the published split, which is wrong by 2x), measured blocks per day, daily emission in ANM and as a percent of supply, network hashrate, and — when the ANM book is fresh — total network-wide mining revenue in USD per day. Buy before holding, quoting or mining ANM. Deterministic, no model. Charges nothing when the chain cannot be read.

Get a post-quantum ML-DSA-65 signature (FIPS 204, scheme 4099 — the same scheme the Animica L1 admits transactions with) over a document you never have to send us. Post a sha256 digest, or post a JSON payload and we canonicalise and hash it here; either way the signature covers the HASH, so the resulting envelope can be published, escrowed or put on-chain without disclosing the content. Buy this when a claim has to stay checkable by a third party years from now — a dataset manifest, a model card, an audit-log segment, a delivery receipt between two agents, the exact bytes of an agreement — because an HMAC proves nothing to anyone but its issuer and an ECDSA signature made today is retrospectively forgeable once a cryptographically-relevant quantum computer exists. You need no PQ library and no key of your own. Verification is FREE (POST /x402/pq/sign/verify) and the signing public key is FREE (GET /x402/pq/sign/pubkey), so anyone can check an envelope offline without paying us. The signed statement records whether YOU or WE computed the digest, because those are different claims. If the signer or its key is not reachable you get a 503 with the reason and are NOT charged — this endpoint has no branch that returns an unsigned envelope.

Which Animica workloads a machine can earn on, in one poll. Per-kind GPU render supply, with the kinds NOBODY serves flagged as supply gaps; the proof-of-work lane off an Animica node (difficulty, thetaMicro, hashrate with unit+window, mempool depth); VRAM floor and deps per kind from the reference miner client; probed enrolment endpoints. Buy it to decide where to point GPU or hash capacity, or to size a box. Empty queues read empty, unreadable ones unreadable. No observable lane, no charge.

Price and feasibility for ONE specific Animica compute job before you pay for it. Send {kind, prompt, quantity} and get the exact cost in atomic units, whether a GPU miner or AICF worker is online for that exact kind right now (with probe age and chain head), the endpoint and body to POST, and a pre-check of your payload. Refuses with 503 and charges nothing when nothing can serve the work. Buy this when a failed render would cost you more than the quote.

Buy when something on Animica looks wrong and you need to know if it really is: an unconfirmed payment, a pool that stopped finding blocks, a bridge deciding to pause. Over recent blocks: interval outliers against the window MEDIAN, each with the count a memoryless chain produces anyway so you can tell noise from signal; producer-concentration SHIFT between halves; mempool backlog vs the chain's own cadence; empty-block runs. No model. Optional ML-DSA-65 attestation. Unreadable node: no charge.

Break-even for Animica mining from live chain state. The per-block miner reward is read off the node's block template, not the params file that still advertises the pre-carve figure; cadence, network hashrate and the ANM bid are measured too. Send hardware cost, watts, $/kWh and either your payout address (we count the blocks it won), your hashrate, or your share. Returns break-even days, the ANM price needed at each horizon, and every assumption named. Says so plainly when it never breaks even.

NOT KYC — CRYPTOGRAPHIC IDENTITY ONLY. This gateway verifies NO real-world identity, runs NO KYC/KYB/AML/sanctions/background check, and endorses nothing you claim; anyone can buy a certificate naming anything, and that disclaimer is inside the signature so it cannot be stripped. What it does prove is cryptographic: Animica signed these exact bytes at this time, and (when key_possession_proven is true) the requester held the secret half of the named key. Get a post-quantum ML-DSA-65 certificate (FIPS 204, scheme 4099 — the same scheme the Animica L1 admits transactions with) binding a self-declared agent name, an optional public key and optional self-declared claims to a signed timestamp and validity window. Buy this when two agents that have never met need a durable, publishable handle for each other: a counterparty id for an escrow row, a stable subject for a reputation record, or a signed statement of what an agent claimed about itself at the moment a deal was struck — evidence that still checks out years later, when a bearer token has expired and an ECDSA signature has become retrospectively forgeable. Send a key_proof (an envelope you self-signed with the key you are naming) and the certificate additionally states you PROVED possession of that key; omit it and the certificate says plainly that the key was only presented. Verification is FREE (POST /x402/pq/identity/verify) and the issuer public key is FREE (GET /x402/pq/identity/key), so any third party can check a certificate offline without paying us. If the signer is unreachable you get a 503 with the reason and are NOT charged.

Bind a build to its identity with a post-quantum signature: POST {name, version, digest} and get an ML-DSA-65 manifest (FIPS 204, alg 4099/0x1003 — the current Animica L1 signature scheme) committing that name+version+digest+timestamp. Buy it after building, training or repackaging something you may later have to prove you published — an image, a wheel, a model checkpoint — or before installing one, so two attestations claiming one name+version with different digests visibly contradict. That question is not answerable from a bare digest signature, which is why this is a separate product from /x402/pq/sign. The manifest also records the Animica chain head read just before signing — or, if the node could not be reached, records that absence and its reason, inside the signature either way, so a missing pin can never be mistaken for one that was never asked for. That pin is the part nobody can move: a block hash cannot be known before its block exists, so the manifest was signed at or AFTER that height, a bound we cannot inflate and anyone can re-check on any Animica node. Nothing is written to the chain. The artifact bytes never leave your side: you send the digest your pipeline already computed (sha256:… , 0x… or bare hex; sha256/sha512/sha3/blake2b/blake3 — SHA-1 and MD5 are refused with a reason, since a collidable digest identifies no single artifact). Optional anchor: the manifest digest is committed as a record in the node data-availability store (da.put), which returns a commitment plus a Merkle inclusion proof against it. Read that for what it is — a node-local, operator-run store, NOT a block: no blob written there is committed by consensus (the live chain's headers carry an all-zero daRoot), and the store evicts (lru) and can be deleted, so the record buys retrievability and tamper-evidence, never a trustless timestamp.

Buy before building or pricing an x402 service. Send an area ("geocoding", "options data"); get the capabilities inside it that few operators serve anywhere in our 18k-service index, each with its listings and, where at least 8 of them publish a usable price, a min/median/p90 band over those advertised prices. Demand appears ONLY where 30-day call and payer counts were observed; every other row is labelled supply-side only, because thin supply is not evidence of demand. Nothing matched: NOT charged.

Buy this before you set or change the price of an x402 endpoint. Send a capability description; get min/median/p90 of what comparable listings in our own ~18,000-service index actually charge, a recommended price that is itself an observed ask, an exact 95% confidence interval for it from the order statistics, and the sample size it rests on. Below 8 priced comparables it refuses and charges nothing. Deterministic arithmetic over real listings — no model.

Backtest a strategy against a price series you supply, with costs, a buy-and-hold benchmark, and a look-ahead guarantee that is structural rather than promised: the strategy is handed a truncated copy of the series and fills at the NEXT bar, so it cannot read the future. Strategies come from a closed vocabulary interpreted by our code — no generated code is ever executed. Returns equity curve, Sharpe, Sortino, max drawdown, profit factor, turnover and costs.

Value at Risk, expected shortfall, drawdown, correlation matrix, concentration and RISK CONTRIBUTION for a portfolio you supply as weights plus return series. Every figure is deterministic arithmetic, reproducible byte-for-byte, with no model involved and no confidence score invented. Risk contribution is the one that changes decisions: a 60/40 book is often a 50/50 risk book. Your positions are never stored and no keys or venue credentials are ever required.