Picocoulombs to Coulombs

One picocoulomb is one trillionth of a coulomb

The prefix pico is a fixed part of the SI: it always means one trillionth, 10^-12. The NIST table of metric SI prefixes lists pico with the symbol p and the factor 10^-12, so 1 pC is 1 x 10^-12 C, which written out is 0.000000000001 C. The NIST Guide to the SI, chapter 4 (updated 2025) adds a rule that matters here: alternative definitions of the prefixes are not permitted, so the factor is a definition, not a measurement that could drift or be rounded.

The coulomb itself is the charge carried by a current of one ampere running for one second, written A s in the SI. To turn any picocoulomb figure into coulombs you divide by 1,000,000,000,000:

• C = pC / 1,000,000,000,000
• or move the decimal point twelve places to the left
• or keep the digits and subtract 12 from the exponent

Because the factor is exact, the conversion never rounds. A charge of 4.7 pC equals 4.7 x 10^-12 C; in reverse, 4.7 x 10^-12 C equals 4.7 pC, with no approximation hiding in either direction. The scale gap is what makes the unit useful: a coulomb is an enormous charge for circuit work, and instruments that count pixels, particles or picoamp currents would need twelve zeros after the decimal point if they wrote everything in coulombs.

Every step on the SI charge ladder divides by 1,000, and the pico step is the smallest one on the ladder. NIST lists each prefix with an exact power of ten, so none of the factors below is a rounded value.

Reading the table upward works the same way in reverse: 1 nC is 1,000 pC, 1 uC is 1,000 nC, and so on. The prefix names come from NIST SP 811, chapter 4 (2008, updated 2025).

Worked conversions: 4.7 pC, 250 pC, 0.8 pC and a negative charge

Start with a datasheet value of 4.7 pC. Subtract 12 from the exponent and keep the digits: 4.7 x 10^-12 C, which is 0.0000000000047 C written out with twelve decimal places. The same steps give 2.5 x 10^-10 C for 250 pC and 8 x 10^-13 C for 0.8 pC.

The decimal point version is worth doing once by hand so the exponent shortcut can be trusted afterwards. Take 250 pC and slide the decimal point twelve places left: 250.0 becomes 0.000000000250. Each step of ten moves the number one place, and after twelve moves you land on 2.5 x 10^-10 C.

Signs ride along unchanged. A charge of -125 pC converts to -1.25 x 10^-10 C; the minus marks which way the electrons moved and survives every arithmetic step. Dropping it when reformatting is a real bug, because in a charge amplifier the sign decides which rail the output sits on.

A direction check catches most slips: the coulomb figure is always smaller than the picocoulomb figure for the same charge, by a factor of a trillion. If your answer came out bigger, the division went the wrong way.

A pC to C table for the numbers that show up on datasheets

The table lists the same charges four ways: the datasheet figure, the scientific notation, the plain decimal and the electron count behind the charge. Electron counts use the exact elementary charge, 1.602176634 x 10^-19 C, from the NIST CODATA entry for the elementary charge.

Read the rows top to bottom and each step multiplies the charge by ten or so; read down the right edge and the electron counts climb from millions to quintillions. The last row is the whole point of the unit: the smallest and largest entries in the table differ by a factor of a trillion, and no single prefix spans both ends.

Charge from capacitance and current: Q = C x V and Q = I x t

Two formulas produce most of the picocoulomb numbers you meet. The first is Q = C x V, the charge stored on a capacitor. A 4.7 pF capacitor charged to 2.5 V holds 4.7 x 10^-12 x 2.5 = 1.175 x 10^-11 C, which is 11.75 pC. The same capacitor at 3.3 V holds 15.5 pC, so the pF figure never pins the charge down until the voltage is named.

The second is Q = I x t, charge delivered by a current over a time. A bias current of 2 pA running for 60 s moves 2 x 10^-12 x 60 = 1.2 x 10^-10 C, which is 120 pC. A 1 nA current delivers 5,000 pC in 5 s, since 10^-9 x 5 = 5 x 10^-9 C. That is why datasheets quote input currents in pA and charge per sample in pC: the two numbers describe one trade between leak speed and integration time.

The calculator above runs both formulas beside the conversion, so you can enter a capacitance and voltage, or a current and a time, and see the resulting charge in picocoulombs and coulombs on the same screen. If a result sits outside the picocoulomb range, the tool still converts it; the prefixes just climb to nano or micro.

Where picocoulombs appear: pixels, piezo sensors and charge counters

Image sensors count electrons one pixel at a time, and each electron carries 1.602176634 x 10^-19 C, an exact value since the 2019 SI redefinition. A pixel holding 50,000 electrons therefore carries 50,000 x 1.602176634 x 10^-19 = 8.0 x 10^-15 C, which is 0.008 pC. A full pixel well of five million electrons reaches about 0.8 pC. Any charge quoted in electrons converts to picocoulombs with one multiplication, which is why sensor reviews switch between the two vocabularies freely.

Piezoelectric force sensors are rated in charge per newton. A sensor marked 25 pC/N pushed with a 12 N load produces 25 x 12 = 300 pC, or 3 x 10^-10 C, at its output. Charge amplifiers integrate that charge and report it in pC, which is why the unit shows up on force, pressure and accelerometer datasheets.

Radiation and particle instruments use the same accounting. A Faraday cup that collects 1 pC has caught about 6.24 million electronic charges, and the electrometer in front of it is specified in pC because that is the whole signal. At this scale a stray finger touch can move a reading, so pC level inputs are guarded, driven and shielded on the board.

Electron counts behind the picocoulomb figures

Because a coulomb is a count of charge carriers, each of the worked examples above has an electron count behind it. The count uses the elementary charge fixed at 1.602176634 x 10^-19 C by the 2019 SI redefinition, which the NIST CODATA listing quotes as an exact value.

The counts are quoted to three figures because the input charges are. A charge of 250 pC works out to 2.5 x 10^-10 / 1.602176634 x 10^-19, which lands near 1.56 billion carriers.

Three checks that catch most pC to C mistakes

First, check the direction. Picocoulombs to coulombs must make the number smaller: 250 pC becomes 2.5 x 10^-10 C, never 2.5 x 10^10. Second, count the zeros if you work in plain decimals. 1 pC is 0.000000000001, with twelve places after the point, and miscounting one zero is a factor of ten. The exponent form avoids the counting altogether: the digits stay where they are and the exponent gains a -12.

Third, run the prefix ladder. The SI staircase from pico up to the plain unit goes pC, nC, uC, mC, C, and each step divides by 1,000. So 4,700 pC is 4.7 nC, 0.0047 uC and 4.7 x 10^-9 C. If a result disagrees with the ladder, one step was skipped or applied twice. The table above shows the same charge in several units at once, which is the fastest way to spot a value that is off by a thousand.

One habit pays for itself on every datasheet: before quoting a converted value, rewrite it in the unit the rest of the document uses. A mixed report that jumps between 0.00000000025 C and 250 pC invites exactly the miscount the checks above exist to catch.

Rounding and writing the answer

Carry the significant figures of the source, not more. A reading of 120 pC has two significant figures, so 1.2 x 10^-10 C is the honest form and 1.20 x 10^-10 C claims a precision the meter never had. A value quoted as 4.7 pC keeps two figures as well; writing 4.699 pC would be false precision dressed up as accuracy.

Scientific notation beats long decimals at this scale because a misplaced zero is invisible inside a row of eleven zeros but obvious as a wrong exponent. When a report needs a plain decimal, print the exponent version beside it. Keep the sign, keep the unit symbol as a lowercase p with an uppercase C, and remember the pico factor is exact, so no rounding error can be blamed on the conversion itself. The only rounding on this page happens at the display step, when a result is formatted for the screen.