code:

import bpy  
from mathutils import Vector  
import math

scene = bpy.context.scene

# Bezier curve function
def Bezier(p0, p1, p2, p3, t):
    u = 1 - t
    b0 = u * u * u
    b1 = 3 * u * u * t
    b2 = 3 * u * t * t
    b3 = t * t * t
    return (b0 * p0) + (b1 * p1) + (b2 * p2) + (b3 * p3)
    
# Derivative of Bezier curve function
def BezierD1(p0, p1, p2, p3, t):
    u = 1 - t
    b0 = 3 * u * u
    b1 = 6 * u * t
    b2 = 3 * t * t
    return (b0 * (p1 - p0)) + (b1 * (p2 - p1)) + (b2 * (p3 - p2))
    
# Second derivative of Bezier curve function
def BezierD2(p0, p1, p2, p3, t):
    u = 1 - t
    b0 = 6 * u
    b1 = 6 * t
    return (b0 * (p2 - (2 * p1) + p0)) + (b1 * (p3 - (2 * p2) + p1))

# ShowCurvature: Generate a new object that shows the curvature of a Bezier curve
def ShowCurvature(curveObjectName, debugObjectName):

    # Create the mesh object
    bpy.ops.object.select_all(action='DESELECT')
    if (scene.objects.find(debugObjectName) >= 0):
        debugObj = scene.objects[debugObjectName]
        debugObj.select_set(True)
        bpy.ops.object.delete()        

    debugMesh = bpy.data.meshes.new(debugObjectName+"Mesh")
    debugObj = bpy.data.objects.new(debugObjectName, debugMesh)
    col = bpy.data.collections.get("Main")
    col.objects.link(debugObj)
    debugObj.select_set(True)

    # Read the Bezier curve points        
    curveObj = scene.objects[curveObjectName]
    spline = curveObj.data.splines[0]

    # Add curve points to new mesh
    verts = []
    edges = []
    faces = []

    numPoints = len(spline.bezier_points)
    edgeIndex = 0
    for curveIndex in range(0,numPoints-1):
        p0 = spline.bezier_points[curveIndex+0].co
        p1 = spline.bezier_points[curveIndex+0].handle_right
        p2 = spline.bezier_points[curveIndex+1].handle_left
        p3 = spline.bezier_points[curveIndex+1].co

        DETAIL = 256
        SCALE = 0.5
        for i in range(0, DETAIL+1):
            t = i / DETAIL
            
            # Find the derivatives
            d1 = BezierD1(p0, p1, p2, p3, t)
            d2 = BezierD2(p0, p1, p2, p3, t)
            
            # Find the "out" vector
            sideways = d1.cross(d2)
            out = d1.cross(sideways).normalized()
            
            # Compute the curvature
            a = ((d2[2] * d1[1]) - (d2[1] * d1[2]))
            b = ((d2[0] * d1[2]) - (d2[2] * d1[0]))
            c = ((d2[1] * d1[0]) - (d2[0] * d1[1]))
            k = math.sqrt((a * a) + (b * b) + (c * c))
            k /= math.pow((d1[0] * d1[0]) + (d1[1] * d1[1]) + (d1[2] * d1[2]), 1.5)

            # Add a line segment            
            d0 = Bezier(p0, p1, p2, p3, t)
            verts.append(d0)
            verts.append(d0 + (out * k * SCALE))
            edges.append((edgeIndex, edgeIndex+1))
            edgeIndex += 2

    # Create the mesh                
    debugMesh.from_pydata(verts, edges, faces)

ShowCurvature("BezierCurve", "DebugMesh")