Tool-Based Destruction for Custom Blocks

Every custom block that can be broken in survival mode begins with the `minecraft:destructible_by_mining` component. This component establishes the baseline hardness of the block before any tool multipliers are applied.

You can declare this component as a simple boolean (`true` to allow breaking with default speed, `false` to make the block unbreakable like bedrock), or as an object containing `seconds_to_destroy`. The value you set in `seconds_to_destroy` represents the time it takes to break the block using an empty hand or an incorrect tool. If you are making an ore or stone block that should punish hand-mining, you set this base number quite high and then lower it for specific tools.

{
  "format_version": "1.21.10",
  "minecraft:block": {
    "description": {
      "identifier": "my_pack:compressed_slate"
    },
    "components": {
      "minecraft:destructible_by_mining": {
        "seconds_to_destroy": 10.0
      }
    }
  }
}

Inside `minecraft:destructible_by_mining`, the `item_specific_speeds` array lets you override `seconds_to_destroy` when the player mines the block while holding a matching item. Each entry in the array pairs an `item` descriptor with its own `destroy_speed` value.

Rather than listing every single vanilla and custom pickaxe by its identifier, the standard practice is to filter by item tags inside the `item` object using a `tags` query. When a player strikes the block, the game checks their held item against this array from top to bottom. If the held item matches the tags, the block uses that entry's `destroy_speed` instead of the base `seconds_to_destroy`.

{
  "format_version": "1.21.10",
  "minecraft:block": {
    "description": {
      "identifier": "my_pack:tin_ore"
    },
    "components": {
      "minecraft:destructible_by_mining": {
        "seconds_to_destroy": 15.0,
        "item_specific_speeds": [
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:wooden_tier')"
            },
            "destroy_speed": 7.5
          },
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:stone_tier')"
            },
            "destroy_speed": 1.15
          },
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:iron_tier')"
            },
            "destroy_speed": 0.75
          },
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:diamond_tier')"
            },
            "destroy_speed": 0.6
          },
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:netherite_tier')"
            },
            "destroy_speed": 0.5
          },
          {
            "item": {
              "tags": "q.all_tags('minecraft:is_pickaxe', 'minecraft:golden_tier')"
            },
            "destroy_speed": 0.4
          }
        ]
      }
    }
  }
}

When writing tag queries inside `item_specific_speeds`, you combine a tool family tag with a material tier tag using `q.all_tags()` or `q.any_tag()`. All vanilla tools and properly configured custom tools carry these built-in tags.

If you only care about the tool type and want all tiers to mine at the exact same speed, you can query the tool tag alone, such as `q.any_tag('minecraft:is_axe')`. If you are building custom tools using the `minecraft:digger` item component, make sure you also assign these standard tags to your custom tool items so third-party custom blocks recognize them automatically.

A crucial detail in Bedrock block design is that `minecraft:destructible_by_mining` only controls how fast the block breaks; it does not stop the block from dropping its loot if mined with a bare hand. Even if a block takes 50 seconds to break by hand, it will still drop its item defined in `minecraft:loot` once those 50 seconds are up.

To make a block drop nothing when broken with the wrong tool (like vanilla stone or ores), you have two options. The modern approach in recent versions is to listen to the `on_player_destroyed` trigger in a `@minecraft/server` custom component script, check the held item in the player's mainhand slot via the `EntityEquippableComponent`, and spawn the loot manually if the tool has the right tags. Alternatively, if you want a pure JSON approach without scripts, you can point `minecraft:loot` to an empty loot table and use `match_tool` conditions inside your loot table JSON to filter by item or enchantment, though loot table tool conditions are more limited with custom item tags than script checks.

import { world, EquipmentSlot, ItemStack } from "@minecraft/server";

world.beforeEvents.worldInitialize.subscribe((event) => {
  event.blockComponentRegistry.registerCustomComponent("my_pack:require_iron_pickaxe", {
    onPlayerDestroy(e) {
      const { player, block } = e;
      if (!player) return;

      const equippable = player.getComponent("minecraft:equippable");
      const mainhand = equippable?.getEquipment(EquipmentSlot.Mainhand);

      if (mainhand && mainhand.hasTag("minecraft:is_pickaxe")) {
        const validTiers = [
          "minecraft:iron_tier",
          "minecraft:diamond_tier",
          "minecraft:netherite_tier"
        ];
        const hasTier = validTiers.some(tag => mainhand.hasTag(tag));
        if (hasTier) {
          block.dimension.spawnItem(new ItemStack("my_pack:raw_tin", 1), block.center());
        }
      }
    }
  });
});

Tool destruction works from two directions: the block can check the tool via `item_specific_speeds`, or a custom tool can check the block via its `minecraft:digger` item component. When you create a custom pickaxe, its `minecraft:digger` component usually looks for vanilla tags on blocks, such as `stone` or `metal`.

To make sure custom tools from your pack or other add-ons recognize your custom block without you having to add every custom tool's identifier into `item_specific_speeds`, add standard vanilla tags to your block's `components` list. A tag is added as an empty JSON object prefixed with `tag:`. Including tags like `tag:minecraft:is_pickaxe_item_destructible` and `tag:stone` ensures that custom digger items and vanilla mechanics treat your block as part of that material family.

{
  "format_version": "1.21.10",
  "minecraft:block": {
    "description": {
      "identifier": "my_pack:tagged_tin_ore"
    },
    "components": {
      "tag:stone": {},
      "tag:minecraft:is_pickaxe_item_destructible": {},
      "tag:minecraft:iron_tier_destructible": {},
      "minecraft:destructible_by_mining": {
        "seconds_to_destroy": 15.0
      }
    }
  }
}

The base `minecraft:destructible_by_mining` component is stable since Bedrock 1.19.40. The `item_specific_speeds` array inside it requires `format_version` 1.21.0 or higher and does not require any experimental toggles.

Read out of the game itself, so the ids match the version you are building for.