diff --git a/_de/items/callbacks.md b/_de/items/callbacks.md
index 86573e5..f1b74ea 100644
--- a/_de/items/callbacks.md
+++ b/_de/items/callbacks.md
@@ -3,14 +3,14 @@ title: Block und Item Callbacks
 layout: default
 root: ../..
 idx: 2.15
-description: Learn about callbacks, actions, and events, including on_use, on_punch, on_place, on_rightclick
+description: Erfahren sie über callbacks, Aktionen, und Ereignissen, einschließlich on_use, on_punch, on_place, on_rightclick
 ---
 
 ## Einleitung  <!-- omit in toc -->
 
 Minetest verwendet hauptsächlich ein Callback-basiertes Modding-Design. Ein Rückruf ist eine Funktion
 die Sie an eine API übergeben und die aufgerufen wird, wenn ein Ereignis eintritt. Zum Beispiel können Sie
-eine Funktion "on_punch" in einer Node-Definition angeben, die aufgerufen wird, wenn ein Spieler
+eine Funktion `on_punch` in einer Node-Definition angeben, die aufgerufen wird, wenn ein Spieler
 einen Knoten anstößt. Es gibt auch globale Callbacks wie
 `minetest.register_on_punchnode`, um Ereignisse für alle Knoten zu empfangen.
 
@@ -20,10 +20,10 @@ einen Knoten anstößt. Es gibt auch globale Callbacks wie
   - [on_drop](#on_drop)
   - [after_use](#after_use)
 - [item_place vs place_item](#item_place-vs-place_item)
-- [Node Callbacks](#node-callbacks)
-  - [Right-clicking and placing a node](#right-clicking-and-placing-a-node)
-  - [Punching and digging](#punching-and-digging)
-  - [...and more!](#and-more)
+- [Block Callbacks](#block-callbacks)
+  - [Rechtsklick und Platzieren eines Blockes](#rechtsklick-und-platzieren-eines blockes)
+  - [Schlagen und abbauen](#schlagen-und-abbauen)
+  - [...und mehr!](#und-mehr)
 
 
 ## Item Callbacks
@@ -83,8 +83,6 @@ Beide Callbacks werden für alle Arten von Items aufgerufen. `on_place` ist stan
 Funktion `minetest.item_place`, die den Aufruf des `on_rightclick`
 Callback des angezeigten Knotens aufruft oder den geschwungenen Gegenstand platziert, wenn es ein Knoten ist.
 
-Übersetzt mit www.DeepL.com/Translator (kostenlose Version)
-
 
 ### on_drop
 
@@ -95,12 +93,12 @@ die Abwurftaste (Q) oder durch Ziehen außerhalb des Inventars. Es wird standard
 
 ### after_use
 
-`after_use` is called when digging a node and allows you to customise how wear
-is applied to a tool. If after_use doesn't exist, then it is the same as:
+`after_use` wird beim abbauen eines Blockes aufgerufen und ermöglicht es Ihnen, dass die Art der Abnutzung
+auf ein Werkzeug angewendet wird. Wenn after_use nicht existiert, dann ist es das gleiche wie:
 
 ```lua
-after_use = function(itemstack, user, node, digparams)
-    itemstack:add_wear(digparams.wear)
+after_use = function(itemstack, benutzer, block, abbauparams)
+    itemstack:add_wear(abbauparams.wear)
     return itemstack
 end
 ```
@@ -108,99 +106,98 @@ end
 
 ## item_place vs place_item
 
-Minetest's API includes many different built-in callback implementations for you
-to use. These callbacks are named with the item type first, for example,
-`minetest.item_place` and `minetest.node_dig`. Some callback implementations are
-used directly whereas some are functions that return the callback:
+Die API von Minetest enthält viele verschiedene integrierte Callback-Implementierungen, zur Benutzung von ihnen. Diese Rückrufe werden mit dem Elementtyp zuerst benannt, zum Beispiel,
+`minetest.item_place` und `minetest.node_dig`. Einige Callback-Implementierungen werden
+direkt verwendet, während einige Funktionen sind, die den Rückruf zurückgeben:
 
 ```lua
-minetest.register_item("mymod:example", {
+minetest.register_item("meinemod:beispiel", {
     on_place = minetest.item_place,
     on_use = minetest.item_eat(10),
 })
 ```
 
-Minetest's API also includes built-in functions that _do_ something. These are
-often named in a confusingly similar way to built-in callback implementations
-but have the verb first. Examples include `minetest.place_item` and
-`minetest.dig_node` - these functions allow you to dig and place nodes with a
-similar effect to players.
+Die API von Minetest enthält auch eingebaute Funktionen, die etwas _tun_. Diese sind
+oft verwirrend ähnlich benannt wie die eingebauten Callback-Implementierungen
+haben aber das Verb vorangestellt. Beispiele sind `minetest.place_item` und
+`minetest.dig_node` - diese Funktionen ermöglichen das abbauen und Platzieren von Blöcken mit einem
+ähnlichen Effekt wie Spieler.
 
 
-## Node Callbacks
+## Block Callbacks
 
-When a node is in an inventory, it uses Item Callbacks, as discussed above. When
-a node is placed in the world, it uses Node Callbacks. There are quite a lot of
-node callbacks, too many to discuss in this book. However, quite a few of them
-will be talked about later in the book.
+Wenn sich ein Block in einem Inventar befindet, verwendet er, wie oben beschrieben, Item Callbacks. Wenn
+ein Knoten in der Welt platziert ist, verwendet er Block Callbacks. Es gibt eine ganze Menge von
+Block Callbacks, zu viele, um sie in diesem Buch zu besprechen. Allerdings werden einige von ihnen
+später in diesem Buch besprochen.
 
-Several of the callbacks are related to node operations such as placing and
-removing from the world. It's important to note that node operation callbacks
-like these aren't called from bulk changes - those that set a large number of
-nodes at once - for performance reasons. Therefore, you can't rely on these
-callbacks to always be called.
+Einige der Rückrufe beziehen sich auf Blockoperationen wie das Platzieren und
+Entfernen aus der Welt. Es ist wichtig zu beachten, dass Blockoperationen-Callbacks
+wie diese nicht von bulk changes aufgerufen werden - also solchen, die eine große Anzahl von
+Blöcken auf einmal setzen - aus Leistungsgründen nicht aufgerufen werden. Daher kann man sich nicht darauf verlassen, dass diese
+Rückrufe immer aufgerufen werden.
 
 
-### Right-clicking and placing a node
+### Rechtsklick und Platzieren eines Blockes
 
-When the user right-clicks with an item whilst pointing at a node, the item's
-`on_place` callback is called. By default, this is set to `minetest.item_place`.
-If the pointed node has an `on_rightclick` callback and sneak (shift) is held,
-then the `on_rightclick` callback is called. Otherwise, `minetest.item_place`
-will place the node.
+Wenn der Benutzer mit der rechten Maustaste auf ein Element klickt, während er auf einen Block zeigt, wird der Callback des Elements
+`on_place`-Callback aufgerufen. Standardmäßig ist dieser auf `minetest.item_place` gesetzt.
+Wenn der gezeigte Knoten einen `on_rightclick` Callback hat und sneak (shift) gehalten wird,
+dann wird der `on_rightclick` Callback aufgerufen. Andernfalls wird `minetest.item_place`
+den Knoten platzieren.
 
-Placing a node will call both `on_construct` and `after_place_node`.
-`on_construct` is called by any node set event that wasn't in bulk and is just
-given the node's position and value .`after_place_node` is only called by node
-place, and so has more information - such as the placer and itemstack.
+Das Platzieren eines Blockes ruft sowohl `on_construct` als auch `after_place_node` auf.
+`on_construct` wird von jedem Block-Plazier-Ereignis aufgerufen, das nicht in Bulk war und wird nur
+die Position und den Wert des Blockes gegeben. `after_place_node` wird nur von node
+place aufgerufen und hat daher mehr Informationen - wie den Placer und den Itemstack.
 
-It's important to note that players aren't the only objects that can place
-nodes; it's common for mobs and mods to place nodes. To account for this,
-`placer` could be a player, entity, or nil.
+Es ist wichtig zu wissen, dass Spieler nicht die einzigen Objekte sind, die
+Blöcke platzieren können; es ist üblich, dass auch Mobs und Mods Blöcke platzieren können. Um dies zu berücksichtigen,
+`Placer` kann ein Spieler, eine Entity oder nil sein.
 
 ```lua
-minetest.register_node("mymod:mynode", {
-    on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
+minetest.register_node("meinemod:meinblock", {
+    on_rightclick = function(pos, block, clicker, itemstack, angeschautes_ding)
         if clicker:is_player() then
-            minetest.chat_send_player(clicker:get_player_name(), "Hello world!")
+            minetest.chat_send_player(clicker:get_player_name(), "Hallo Welt!")
         end
     end,
-    on_construct = function(pos, node)
+    on_construct = function(pos, block)
         local meta = minetest.get_meta(pos)
-        meta:set_string("infotext", "My node!")
+        meta:set_string("infotext", "Mein Block!")
     end,
-    after_place_node = function(pos, placer, itemstack, pointed_thing)
-        -- Make sure to check placer
-        if placer and placer:is_player() then
+    after_place_node = function(pos, plazierer, itemstack, angeschautes_ding)
+        -- Stellen Sie sicher, dass Sie den Plazierer überprüfen
+        if plazierer and plazierer:is_player() then
             local meta = minetest.get_meta(pos)
-            meta:set_string("owner", placer:get_player_name())
+            meta:set_string("besitzer", plazierer:get_player_name())
         end
     end,
 })
 ```
 
-### Punching and digging
+### Schlagen und abbauen
 
-Punching is when the player left-clicks for a short period. If the wielded item
-has an `on_use` callback, this will be called. Otherwise, the `on_punch`
-callback on the pointed node will be called.
+Schlagen bedeutet, dass der Spieler kurz mit der linken Maustaste klickt. Wenn der benutze Gegenstand
+einen `on_use` Callback hat, wird dieser aufgerufen. Andernfalls wird der `on_punch`
+Callback auf dem angezeigten Block aufgerufen.
 
-When the player attempts to dig a node, the `on_dig` callback on the node will be called.
-This defaults to `minetest.node_dig`, which will check for area protection, wear
-out the tool, remove the node, and run the `after_dig_node` callback.
+Wenn der Spieler versucht, einen Block abzubauen, wird der `on_dig` Callback auf dem Knoten aufgerufen.
+Dieser ist standardmäßig auf `minetest.node_dig` eingestellt, der den Gebietsschutz prüft, das
+das Werkzeug verschleißt, den Block entfernt und den `after_dig_node` Callback ausführt.
 
 
 ```lua
-minetest.register_node("mymod:mynode", {
-    on_punch = function(pos, node, puncher, pointed_thing)
-        if puncher:is_player() then
-            minetest.chat_send_player(clicker:get_player_name(), "Ow!")
+minetest.register_node("meinemod:meinblock", {
+    on_punch = function(pos, block, schlaeger, angeschautes_ding) -- ä wird außer in strings und Kommentaren zu ae
+        if schlaeger:is_player() then
+            minetest.chat_send_player(clicker:get_player_name(), "Au!")
         end
     end,
 })
 ```
 
-### ...and more!
+### ...und mehr!
 
-Check out Minetest's Lua API reference for a list of all node callbacks, and
-more information on the callbacks above.
+In der Lua-API-Referenz von Minetest finden Sie eine Liste aller Node-Callbacks und
+weitere Informationen zu den oben genannten Rückrufen.