Tok{In} API
The Tok{In} API offers an array of features that can help determine whether a token is malicious or not. From storage checks, to simulation and static analysis features. The Tok{In} API supports all ERC20 contracts on Ethereum, Binance Smart Chain, Arbitrum, Base, Avalanche, and Robinhood Chain (New). The features cover all Uniswap V2/V3/V4 forks, Aerodrome V2/Slipstream (Base), and launchpad tokens: both bonding curves (four.meme and flap.sh on BSC, trench.today and flap on Robinhood Chain) and launchpads that seed a standard DEX pool directly (Pons, Noxa, Virtuals, Doppler, varo.rialto, bow.fun and letscash.fun on Robinhood Chain).
For AI coding agents (Claude Code, Cursor, Copilot, etc.): a migration guide written specifically for you lives at
AGENTS.mdalongside this page (canonical URL:https://docs.dedaub.com/docs/token_safety/AGENTS). Read it end-to-end before changing any code that integrates with Tok{In}: it covers the GoPlus → Tok{In} drop-in swap, field mappings, always-nullfields, and common migration pitfalls.
Authentication
Every request needs a Tok{In} key in the X-API-Key header. Sign in at tokin.dedaub.com, open API Keys, click Create Key and then Generate Key. A key from your app.dedaub.com profile does not work here. See API Keys.
Usage
curl -X 'GET' \
'https://tokin-api.dedaub.com/token/{chain}/{token_address}' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR-API-KEY'
chain: The slug or the EVM chain id of the chain (see Available Chains)
token_address: The address of the token
Optional query parameters:
| Parameter | Default | Effect |
|---|---|---|
response_format | dedaub | goplus gives the GoPlus-compatible shape. See Response Formats. |
include_token_price | false | true fills the four price fields. Without it they are null. See Price fields. |
refresh | false | true computes the state part of the analysis again (pools, state features, source analysis). It needs an enterprise plan or an admin key. If not, the API answers 403. |
redecompile | false | true runs the decompiler again. It needs an enterprise plan or an admin key. If not, the API answers 403. |
User Interface
A Swagger UI for easier interaction with the API is available at https://tokin-api.dedaub.com . The field descriptions in the Swagger UI are short. This page is the full reference.
Available Chains
| Chain | Slug | Chain ID |
|---|---|---|
| Ethereum | ethereum | 1 |
| Binance Smart Chain | binance | 56 |
| Arbitrum | arbitrum | 42161 |
| Base | base | 8453 |
| Avalanche | avalanche | 43114 |
| Robinhood Chain (New) | robinhood | 4663 |
DEX coverage is most complete on Ethereum, with more pools being added to the other chains over time.
Quote tokens per chain
Pool discovery and liquidity valuation are anchored on each chain's wrapped native token plus its canonical ~$1 stablecoins. That anchor set is not the same on every chain:
| Chain | Wrapped native | Stable anchors |
|---|---|---|
| Ethereum, Arbitrum, Base | WETH | USDC, USDT |
| Binance Smart Chain | WBNB | USDC, USDT |
| Avalanche | WAVAX | USDC, USDT |
| Robinhood Chain | WETH | USDG, USDE |
Robinhood Chain has no canonical USDC or USDT: USDG and USDE are the real ~$1 tokens there, and any USDC/USDT-named deployment on 4663 is an impostor. Pools quoted in a non-anchor token can still be valued when a price is available (see Notes on liquidity).
Response Formats
The Tok{In} API supports multiple response formats via the response_format query parameter.
Available Formats
| Format | Description |
|---|---|
dedaub | Default format |
goplus | GoPlus-compatible format |
Usage
# Default (Dedaub format)
GET /token/{chain}/{token_address}
# GoPlus format
GET /token/{chain}/{token_address}?response_format=goplus
GoPlus Format Mapping
The GoPlus format transforms the default Tok{In} schema to a GoPlus-compatible one, with the following caveats.
Direct Mappings
| Dedaub Field | GoPlus Field | Notes |
|---|---|---|
is_open_source | is_open_source | Boolean → "1"/"0" string |
is_proxy | is_proxy | Boolean → "1"/"0" string |
mint_or_burn_function | is_mintable | Boolean → "1"/"0" string |
owner_address | owner_address | Direct string. Not a renouncement signal, see caveat 7 |
can_selfdestruct | selfdestruct | Boolean → "1"/"0" string |
external_call | external_call | Boolean → "1"/"0" string |
is_in_dex | is_in_dex | Boolean → "1"/"0" string |
receive_tax | buy_tax | Percentage as string ("1" is 1%); pool-aware, see caveat 4; scale, see caveat 8 |
send_tax | sell_tax | Percentage as string ("1" is 1%); pool-aware, see caveat 4; scale, see caveat 8 |
cannot_buy | cannot_buy | Boolean → "1"/"0" string |
tax_can_be_modified | slippage_modifiable | Boolean → "1"/"0" string. Not owner-gated |
trading_cooldown | trading_cooldown | Boolean → "1"/"0" string |
creator_address | creator_address | Direct string |
creator_percent | creator_percent | Percentage as string ("0.02" is 0.02%); scale, see caveat 8 |
is_launchpad_token | launchpad_token | Boolean → "1"/"0" string |
Computed Mappings
| GoPlus Field | Derived From | Logic |
|---|---|---|
transfer_pausable | cannot_buy, pause_status_can_be_modified | True if either is True. Reads pause_status_can_be_modified after the owner gate |
is_blacklisted | has_blacklist_or_whitelist | Same value (temporary) |
is_whitelisted | has_blacklist_or_whitelist | Same value (temporary) |
is_anti_whale | has_trading_cap, has_position_cap | True if either is True |
anti_whale_modifiable | trading_cap_can_be_modified, position_cap_can_be_modified | True if either is True. Reads both flags after the owner gate |
hidden_owner | allowance_bypass, privileged_spenders | True when the bypass is address specific, so at least one address is named |
owner_change_balance | owner_can_change_balance | Same value. null while the owner simulation is off. It is off today |
Fields Without Direct Equivalent (returns null)
| GoPlus Field | Reason |
|---|---|
cannot_sell_all | Not currently tracked |
can_take_back_ownership | Not currently tracked |
gas_abuse | Not currently tracked |
personal_slippage_modifiable | Not currently tracked |
lp_total_supply | Not currently tracked |
is_airdrop_scam | Not currently tracked |
trust_list | Not currently tracked |
holder_count | Not currently tracked |
owner_balance | Not currently tracked |
owner_percent | Not currently tracked |
Caveats
-
is_blacklisted/is_whitelisted: Currently both map fromhas_blacklist_or_whitelist. We cannot distinguish between blacklist-only, whitelist-only, or both. -
Boolean Format: GoPlus uses string format (
"1"/"0") instead of booleans. All boolean fields are converted accordingly. -
Tax Terminology: Our
send_taxmaps to GoPlussell_tax, and ourreceive_taxmaps to GoPlusbuy_tax. Note the direction inverts: code computing slippage must follow the rename. -
buy_tax/sell_taxare pool-aware, and may disagree with the contract-level tax. Ingoplusmode these are taken from the first pool index[]that reports a tax, falling back to the contract-levelreceive_tax/send_taxonly when no pool reports one. The pool figure reflects what a real swap would cost and is usually the more useful number, but it meansbuy_taxin agoplusresponse can differ fromreceive_taxin the equivalentdedaubresponse for the same token. If you compare the two formats, expect this and prefer the pool figure for trade decisions. -
is_honeypotis alwaysnull. It is present in the response shape but not yet produced. Integrations that gate trades onis_honeypot === "1"will treat every token as safe after migrating. Derive an equivalent fromcannot_buy, the per-pooldex[].buy_success/sell_success(dedaubmode), and the tax fields; or block while the field is unavailable. See Readingbuy_success/sell_successfirst, because thenull/"pending"states matter for exactly this decision. -
hidden_owneris narrower than it looks: it is"1"only when the bypass is address-specific. A universal bypass (where the allowance check is skipped for everyone) setsallowance_bypassbut leavesprivileged_spendersempty, and maps to"0"because no undisclosed owner exists. It isnullwhen the check could not run, which is not the same as"0". Use the Dedaub format if you need to tell those three apart, or to read the offending addresses. -
No GoPlus field carries the ownership verdict or the timebomb result.
ownership_renounced,timebomb_statusandtimebomb_deadlinesare only in thededaubformat. Do not useowner_addressto decide if ownership is renounced. It is the answer of an owner getter, and it isnullwhen no getter answered. In that case the verdict can be "renounced" or "not determined" (seeownership_renounced).transfer_pausableandanti_whale_modifiableread the setter flags after the owner gate. So"0"can mean that the code has a setter, but the owner is gone.slippage_modifiableis not owner-gated. -
buy_tax,sell_taxandcreator_percentare percentages."1"is 1%. The GoPlus API uses a 0–1 scale for these fields, where"0.01"is 1%. A client that reads these values on the GoPlus scale gets a value that is 100 times too high.holders[].percentuses the 0–1 scale of GoPlus. The Swagger UI text for these fields says 0–1 today. That text is wrong. Use the scale on this page.
Static Analysis Features
We leverage the Gigahorse decompiler to analyze contracts whose source code is unavailable. The decompiled bytecode is checked for patterns commonly associated with undesirable behaviors in ERC20 tokens.
mint_or_burn_function:
There is a public function that changes the token's total supply.
can_selfdestruct:
The contract contains a selfdestruct call. (Note: The EVM no longer supports the SELFDESTRUCT opcode, so this is now a no-op.)
transfer_guarded_by_storage:
The transfer function's execution depends on a storage variable (e.g., a flag or mapping check). This is a signal that transfers can be conditionally blocked by the contract owner or via some internal logic.
transfer_from_guarded_by_storage:
The transferFrom function's execution depends on a storage variable. Same implications as transfer_guarded_by_storage: it indicates that delegated transfers can be conditionally blocked.
trading_cooldown:
An address must wait for a certain period after its last transfer before it can transfer tokens again.
view_function_modifies_state:
A function with the signature of one of the view functions defined by EIP-20 updates a storage variable.
has_trading_cap:
The amount of tokens transferred by a single call to transfer cannot exceed a value, either constant or held in storage.
has_trading_cap_functionality:
There is code that could enforce a trading cap. This can be true even if the cap is disabled.
trading_cap_can_be_modified:
The transfer amount cap is held in storage and there is a function that can update it. The API sends false when ownership_renounced is true. When ownership_renounced is false or null, the flag keeps the static result. See Owner-gated setters.
has_position_cap:
The amount of tokens an address can hold cannot exceed a value, either constant or held in storage.
has_position_cap_functionality:
There is code that could enforce a position cap. This can be true even if the cap is disabled.
position_cap_can_be_modified:
The position cap is held in storage and there is a function that can update it. The API sends false when ownership_renounced is true. When ownership_renounced is false or null, the flag keeps the static result. See Owner-gated setters.
has_owner_functionality:
There is functionality that could let one or more addresses have access to functionality of the token that the rest do not. This can be true even if the owner has been renounced. For the current owner state, read ownership_renounced.
owner_address:
The address that an owner getter gives: owner(), getOwner() or _owner(). The API calls the getters at the token address. For a proxy, the call goes through the proxy to the implementation code. When two getters answer, a live address comes before a burn address. null when no getter answered.
Do not use this field to decide if ownership is renounced. Read ownership_renounced.
ownership_renounced:
The ownership verdict of the API.
| Value | Meaning |
|---|---|
true | Renounced. An owner getter gave a burn address. Or no owner getter answered, and the API did not find a wallet in a storage slot that the code uses for its owner checks. The API also gives true when it did not read that slot: there is no analysis, the code keeps its state at a different address, the slot is not a plain address slot, the read failed, or the read took more than 2 seconds. |
false | Live. An owner getter gave an address that is not a burn address. |
null | Not determined. No owner getter answered, but a wallet is in a storage slot that the code uses for its owner checks. Show it as unknown, never as renounced. |
true with owner_address: null means that no owner getter answered. A contract with no owner getter can still give privileges in a different way. Examples are roles, or a contract address in storage, such as a multisig or a timelock. A contract in an owner slot does not change the verdict to null. A slot that the API did not read also leaves true. So in this case true does not prove that nobody has privileges. Read has_owner_functionality too.
When the value is true, the API sends false for three setter flags. See Owner-gated setters.
Since 2026-10-03, the API reads the owner of a proxy through the proxy, and a wallet in an owner slot gives null. Before that date, some proxies (for example USDC and BUSD on Ethereum) and some tokens with a wallet in an owner slot showed true.
⚠ Do not calculate this value from owner_address. The verdict also reads storage, so the two fields can disagree. For example, owner_address is null both when the verdict is true and when it is null.
⚠ Test the key, then the value. null is an answer: "not determined". A response that the API sent before 2026-08-24 does not have this key. Use a fallback only when the key is absent.
has_pause_functionality:
The token has code that could pause trading. Can be true even if the current state of the contract does not allow pausing functionality to be re-enabled.
pause_status_can_be_modified:
The pause status can be changed in the future. The API sends false when ownership_renounced is true. When ownership_renounced is false or null, the flag keeps the static result. See Owner-gated setters.
has_blacklist_or_whitelist:
Addresses can be restricted from trading the token.
external_call:
There is a call to another contract, whose target is not statically known and/or returns arbitrary data that are used by the token.
timebomb:
The code compares a value with block.number or block.timestamp, so some behaviour can start or stop when the chain clock gets to that value. The API places each value against the chain clock and gives the result in timebomb_status and timebomb_deadlines.
timebomb is false when timebomb_status is passed or unreachable, also when the code has the check. Every other status keeps the static finding. A status never changes timebomb from false to true. "pending" means that the analysis has not run.
timebomb_status:
Where the time checks of the code stand now. The API calculates this value each time it builds a response, not at last_scanned_at. A response can come from a cache that is at most two minutes old. So the value can change with time, also when no transaction occurs.
| Value | Meaning | timebomb |
|---|---|---|
armed | A deadline is still ahead. The behaviour of the contract can change when the chain gets to it. | true |
passed | Every deadline has passed, and nobody can move a deadline. Its effect is now the current behaviour, and the other checks measure it. | false |
resettable | No deadline is ahead, but a value in storage can still change. The owner is live or not determined. Or a storage slot for the owner checks holds a value other than zero or a burn address, or the API could not read it. A storage value that is out of reach also gives this status while the owner is not gone. It is a deadline that nobody set yet. | true |
unreachable | The code compares the clock only with limits that no clock gets to, for example the overflow limit 2^32 or the uint48 maximum. These limits are not timers. A storage value at such a limit also gives this status, but only when the owner is gone. | false |
unknown | The API could not place a value against the clock. Or a deadline in storage has passed, but it is not old enough yet (see below). Also when the chain did not answer in 5 seconds. | true |
null | There is no timebomb finding, or the analysis has not run. | false or "pending" |
When the values of one token point to different statuses, the API gives the first status that applies, in this order: armed, unknown, resettable, passed, unreachable. For example, the owner of BAT is not determined, but the API could not place its values, so the status is unknown.
How the API places a value:
- It reads the clock that the contract reads. It runs
block.numberandblock.timestampin a call, and does not read a block header. - A value in the range of Unix time is a timestamp.
- A block number counts only from about two years before the current block to ten years after it. It must also not be a multiple of 60. A duration such as
2592000(30 days) looks like a block number, so an older value or a multiple of 60 is not placed. - A value that is more than ten years ahead of both clocks is a limit (
unreachable). - Other values, for example zero, a small number, a duration or an old block number, are not placed. They give
unknown, unless a deadline is still ahead (armed). - A deadline in storage counts as passed only when the owner is gone and the deadline is old enough. A timestamp must be more than one year old. For a block, the API counts the age at half the nominal block time. So the block must be about two years old by the nominal block time. The code can add a time to the stored value that the analysis does not see.
Live examples on Ethereum, 2026-10-03:
| Token | timebomb_status | timebomb | Why |
|---|---|---|---|
TORN 0x77777feddddffc19ff86db637967013e6c6a116c | passed | false | The bytecode compares the clock with the constant timestamp 1612148437 (2021-02-01). It has passed, and it cannot change. |
COMP 0xc00e94cb662c3520282e6f5717214004a7f26888 | unreachable | false | The code compares the clock only with 0x100000000 (2^32). |
UNI 0x1f9840a85d5af5bf1d1762f925bdaddc4201f984 | resettable | true | The stored deadline in slot 0x2 (2024-01-01) has passed. The minter address in slot 0x1 can still write a new one. |
BAT 0x0d8775f648430679a709e98d2b0cb6250d2887ef | unknown | true | The code compares block.number with two stored block numbers from 2017. A block number that old is not placed. |
timebomb_deadlines:
The blocks and times that the code compares with its clock, where the API could place them. The list is in the order of estimated_unix_time.
| Field | Meaning |
|---|---|
source | constant: the value is in the bytecode and cannot change. storage: the value comes from a storage slot. |
slot | The storage slot of a storage value. null for a constant. |
clock | block (a block number) or timestamp (Unix seconds). |
value | The block number or the Unix timestamp. |
passed | true when the clock is at or after value. |
estimated_unix_time | When the clock gets to value, in Unix seconds. Exact for a timestamp. For a block, an estimate from the nominal block time of the chain. |
A limit (unreachable) and a value that the API could not place are not in the list. So the list can be empty, also when timebomb_status is unreachable or unknown. A deadline with passed: true does not turn timebomb off by itself. Read timebomb_status.
⚠ estimated_unix_time of a block is only an estimate. It can be wrong by a large amount, and it changes between two responses. On Binance Smart Chain it can move by minutes, because the real block time is shorter than the nominal block time. For a decision, use passed, which compares with the current block and is exact.
⚠ Arbitrum and Robinhood Chain. On these chains, block.number in a contract gives the Ethereum block number. So a block deadline is an Ethereum block, and its estimated_unix_time uses the Ethereum block time. Do not compare it with the L2 block number in an explorer.
UNI on Ethereum, live on 2026-10-03:
"ownership_renounced": true,
"timebomb": true,
"timebomb_status": "resettable",
"timebomb_deadlines": [
{
"source": "storage",
"slot": "0x2",
"clock": "timestamp",
"value": 1704067200,
"passed": true,
"estimated_unix_time": 1704067200
}
]
The deadline has passed, but timebomb stays true. UNI has no owner getter and its minter is a contract, so ownership_renounced is true. But slot 0x1 holds the minter address, so the stored deadline can still change, and the status is resettable.
has_tax_functionality:
This token has a tax functionality implemented. This could be true even if the current tax is 0 as the taxes could have been wiped.
tax_can_be_modified:
Tax value can be updated. This flag is not owner-gated: the API sends the static result also when ownership_renounced is true. See Owner-gated setters.
is_open_source:
This indicates whether the contract's source code is available.
has_open_source_implementation:
For proxy contracts: indicates whether the implementation contract's source code is verified. Only relevant when is_proxy is true. null for non-proxy contracts.