Biotechnology · Intermediate

Affinity chromatography elution

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Affinity chromatography captures a target protein on an immobilized ligand and then releases it in a step called elution. Elution works by breaking the specific ligand-target interaction, using a competitor, a pH or ionic strength change, or a denaturant. The simulation shows how elution conditions shift the balance between bound and free protein.

Intuition

Think of the target protein as a key held in many matching locks on beads. Washing removes everything that does not fit. To release the key you must either flood the column with a competing molecule that fits the lock better or in higher number, or change the environment so the key and lock no longer grip well. A competitor such as imidazole for His-tagged proteins, or free sugar for lectin columns, pushes the equilibrium toward free protein. A low pH buffer changes charges and hydrogen bonds so binding weakens. Gentle elution preserves activity, while harsh elution gives sharp peaks but risks denaturation. The protein leaves as a peak because it is released in a narrow zone and carried along by the flow.

Key equations

Kd=[P][L][PL]
(1)

Dissociation constant of the protein-ligand complex; a small Kd means tight binding.

[PL][P]total=[L]Kd+[L]
(2)

Fraction of protein bound to free ligand sites.

Kapp=Kd(1+[C]KC)
(3)

Competitive elution: competitor C at concentration [C] with its own constant Kc raises the apparent Kd, weakening binding to the column.

Ve=elution volume at peak maximum
(4)

Elution volume, the buffer volume at which the peak emerges, used to judge sharpness and dilution.

Derivation

  1. Start with the binding equilibrium P + L ⇌ PL with Kd = [P][L]/[PL].
  2. Fraction bound is [PL]/([P]+[PL]) = [L]/(Kd+[L]).
  3. Add a competitor C that binds the same site: C + L ⇌ CL with Kc = [C][L]/[CL].
  4. The total ligand is [L]+[PL]+[CL]; the competitor reduces free L available to the protein.
  5. Rewriting the protein's equilibrium gives an apparent Kd of Kd(1+[C]/Kc).
  6. Raising [C] increases Kapp, so the bound fraction falls and the protein desorbs and moves with the buffer.
  7. For pH elution, protonation changes the interaction so Kd itself rises sharply.

Worked example

Problem

A His-tagged protein binds a Ni-NTA column with Kd = 1 µM for the effective site. Imidazole has Kc = 10 mM. By what factor does 250 mM imidazole raise the apparent Kd, and how does the bound fraction change if free ligand site concentration is 10 µM?

  1. Compute the factor: 1 + 250/10 = 26.
  2. Kapp = 1 µM × 26 = 26 µM.
  3. Bound fraction without competitor: 10/(1+10) = 0.91.
  4. Bound fraction with competitor: 10/(26+10) = 0.28.
  5. So most protein is now free and elutes.

Answer Apparent Kd rises 26-fold, to 26 µM, and the bound fraction falls from about 91% to about 28%.

Common mistakes

  • Thinking elution only dilutes the protein rather than shifting the binding equilibrium.
  • Using a low pH without neutralizing the fractions afterward, which damages the protein.
  • Using too little competitor so the protein elutes in a broad, weak tail.
  • Confusing wash and elution: washing should keep the target bound.
  • Forgetting to remove the competitor, such as imidazole, by dialysis or desalting.

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(89 lines)
import sys
import numpy as np
from manim import *
from blocks import *


def simulate(n_steps=60, dt=1.0, c_load=1.0, k_off_wash=0.002, k_off_elute=0.25,
             load_end=20, wash_end=35, q0=0.0):
    """Fixed-step simulation of bound target q on resin and eluted signal c.
    Phase 1: loading (binding), 2: wash (weak leak), 3: elution (competitor/low pH)."""
    q = q0
    qmax = 1.0
    k_on = 0.08
    rec = []
    for i in range(n_steps + 1):
        t = i * dt
        if t < load_end:
            inflow = c_load
            dq = k_on * inflow * (qmax - q) - k_off_wash * q
            out = 0.02 * inflow * (1 - (qmax - q))  # small breakthrough
        elif t < wash_end:
            dq = -k_off_wash * q
            out = 0.0
        else:
            dq = -k_off_elute * q
            out = -dq  # released protein leaves the column
        rec.append((t, q, out))
        q = max(0.0, q + dq * dt)
    return rec


TRACE = simulate()


def build_arrays():
    t = np.array([r[0] for r in TRACE])
    q = np.array([r[1] for r in TRACE])
    o = np.array([r[2] for r in TRACE])
    return t, q, o


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14171c"
        TitleCard(self, "Affinity chromatography", "Bind, wash, elute")
        t, q, o = build_arrays()
        # plot of bound protein and eluted signal
        plot = CurvePlot(lambda x: 0, x_range=(0, 60, 10), y_range=(0, 1, 0.5),
                         x_label="time", y_label="amount", x_length=9, y_length=4.2)
        plot.remove(plot.curve)
        plot.move_to(ORIGIN + 0.1 * DOWN)
        self.play(Create(plot.axes), FadeIn(plot.labels))
        ax = plot.axes
        omax = max(o.max(), 1e-9)
        bound = VMobject(color=C_MAIN)
        bound.set_points_as_corners([ax.c2p(a, b) for a, b in zip(t, q)])
        peak = VMobject(color=C_GOOD)
        peak.set_points_as_corners([ax.c2p(a, b / omax * 0.6) for a, b in zip(t, o)])
        # phase labels
        phases = [("Load", 0, 20), ("Wash", 20, 35), ("Elute", 35, 60)]
        cols = [C_MAIN, C_DIM, C_GOOD]
        tags = VGroup()
        for (name, a, b), c in zip(phases, cols):
            tg = Text(name, font_size=24, color=c).move_to(ax.c2p((a + b) / 2, 1.0))
            tags.add(tg)
        key1 = Text("bound protein", font_size=24, color=C_MAIN)
        key2 = Text("eluted signal", font_size=24, color=C_GOOD)
        keys = VGroup(key1, key2).arrange(RIGHT, buff=0.8).next_to(ax, DOWN, buff=0.5)
        self.play(FadeIn(keys))
        # animate phases using recorded states
        for (name, a, b), tg in zip(phases, tags):
            self.play(FadeIn(tg), run_time=0.4)
            if name == "Elute":
                self.play(Create(bound.copy().set_stroke(opacity=0)), run_time=0.01)
        self.play(Create(bound), run_time=3, rate_func=linear)
        self.play(Create(peak), run_time=2, rate_func=linear)
        StepCaption(self, "Target binds the resin, impurities wash out, elution releases a sharp peak")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    t, q, o = build_arrays()
    assert t[0] == 0 and q[0] == 0
    assert q.max() <= 1.0 + 1e-9 and q.min() >= 0
    assert q[20] > 0.7  # resin mostly loaded
    assert q[-1] < 0.05 * q[35] + 1e-3  # elution strips resin
    assert o[36:].max() > 10 * o[21:35].max() + 1e-12
    assert int(np.argmax(o)) in (35, 36)
    print("ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.