Schnellstart-Tutorial

API-Zugang erfordert Genehmigung

Um die Legalesign-API zu nutzen, müssen Sie uns kontaktieren, um die Nutzung der API für Ihr Konto genehmigen zu lassen.

Tipp

Verwenden Sie Cursor, Claude oder ein anderes KI-Codierungstool? Verbinden Sie es mit den Legalesign-Dokumentationen für kontextabhängige Hilfe, während Sie dieses Tutorial durchlaufen.

In diesem Tutorial führen Sie die wichtigsten API-Aufrufe durch, die die meisten Entwickler für eine eSignature-Integration benötigen – das Hochladen eines Dokuments und das Versenden zur Unterschrift.

Die Legalesign-API ist skalierbar, vielseitig und seit vielen Jahren in den Systemen unserer Kunden produktiv getestet. Sie können sie für ein einfaches Dokument mit einem Unterzeichner verwenden oder Dokumente zum Bezeugen oder zur Genehmigung versenden, optimiert für Stapelverarbeitungen, mit Formularen und mehr. Sie können sie für einen Zweck integrieren oder in Ihre Software für Ihre Kunden einbetten – siehe Integrationen.

Die REST-API erledigt die meisten Funktionen und ist der einfachste Einstieg. Wenn Sie mehr benötigen, schauen Sie sich die GraphQL-Schnittstelle an. Legalesign ist API-zuerst mit GraphQL. Sie können beide verwenden, je nach Präferenz.

Wir folgen diesen Schritten:

1. Erstellen Sie ein Konto + API-Schlüssel (siehe API-Zugang verifizieren).
2. Bestätigen Sie, dass die Anmeldedaten funktionieren, und erhalten Sie Ihre Team-ID.
3. Laden Sie ein Dokument über die Web-App hoch.
4. Versenden Sie dieses zur Unterschrift über die API.
5. Laden Sie es nach der Unterschrift herunter.
6. Laden Sie ein Dokument über die API hoch.

Die Legalesign REST-API ist einfach zu verwenden. Die technische Referenz enthält einen Code-Editor. Sie können Anfragen direkt aus der technischen Referenz mit Ihrem API-Schlüssel stellen, ansonsten kopieren Sie einfach den Code und fügen ihn in Ihren Code ein.

Abbildung 1: Der REST API Code-Editor.

Client-Bibliotheken

• C# + Anleitung
• Java
• Node.js
• PHP
• Python
• Ruby

Oder für die GraphQL-Schnittstelle Node.js

Tipp

Wir empfehlen Entwicklern, direkt mit der API statt mit den SDKs zu arbeiten. Zur Unterstützung gibt es einen Cut-and-Paste-Code-Generator in der technischen Spezifikation, und Ihre KI kann schnell Beispiele unter Verwendung der OpenAPI-Spezifikation erzeugen. Warum? Die Quell-API hat mehr Funktionalitäten als SDKs, Sie möchten sowieso die Endpunkte kennen, die Sie verwenden, Sie vermeiden Abstraktions-Overhead und Abhängigkeiten, und—basierend auf unserer Erfahrung—kommen Sie schneller ans Ziel.

1. Erstellen Sie ein Konto

Gehen Sie zu Legalesign Anmeldung. Verwenden Sie eine normale E-Mail zur Kontoerstellung (verwenden Sie nicht Google), föderierte Identitäten wie Google funktionieren nicht für die API.

Sie werden aufgefordert, ein Team zu erstellen. Teams sind die Bausteine von Legalesign. Die gesamte Dokumentenbearbeitung findet in einem Team statt. Sie müssen in den meisten API-Aufrufen auf Ihr Team verweisen.

Info

Ein 'Team' oder eine 'Gruppe' sind dasselbe. In der Web-App sprechen wir von 'Teams', aber im API-Schema ist es eine Gruppe.

Kontaktieren Sie den Support für einen API-Schlüssel. Teilen Sie uns Ihren Anwendungsfall, Ihre API-Entwicklungserfahrung und einige Details mit, damit wir bestätigen können, dass Sie echt sind (z. B. Details Ihres Arbeitsplatzes).

API-Einstellungen

Sobald Sie verifiziert sind, gehen Sie zum API-Dashboard. Generieren Sie Ihre API-Anmeldeinformationen im Abschnitt API-Schlüssel.

Nehmen Sie sich einen Moment, um das Developer-Portal zu prüfen.

Sandbox

Im Abschnitt Umgebung wird eine Warnung angezeigt, ob Sie sich im Sandbox- oder Produktionsmodus befinden.

Sandbox begrenzt, wohin Sie Ihre Dokumente senden können. Sie sehen ein Formular, um bis zu 5 genehmigte E-Mails hinzuzufügen – fügen Sie jetzt ein paar hinzu.

Wenn Ihre Integration bereit ist: wechseln Sie in den Produktionsmodus.

Tipp

Erstellen Sie ein zweites Team. Verwenden Sie Ihr erstes Team für die Entwicklung und andere Teams für die Produktion. Teilen Sie dem Support den Namen Ihres Dev-Teams mit, damit es von der Abrechnung ausgeschlossen wird.

API-Schlüssel

Im API-Schlüssel-Abschnitt sehen Sie die Details Ihrer API-Schlüssel. Der Schlüssel selbst wird nur bei Erstellung angezeigt.

Der Schnellstart-Abschnitt enthält Beispiele zum Kopieren und Einfügen, um Ihren Schlüssel zu testen.

Webhooks & Protokolle

Fügen Sie Webhooks hinzu (Ihre Listener für Legalesign-Ereignisse) und überprüfen Sie Ihre Protokolle.

2. Eine erfolgreiche GET-Anfrage

Die Root-URL ist immer: https://eu-api.legalesign.com/

Beginnen Sie mit einer GET-Anfrage, um zu bestätigen, dass Ihre Anmeldedaten funktionieren. Ersetzen Sie Benutzernamen und geheime Werte im untenstehenden Code.

Curl wird in den Beispielen verwendet und Sie können zwischen cURL, Node.js, Python, C# und Go mit den untenstehenden Tabs wechseln.

cURL

curl -H "Authorization: ApiKey username:secret" -H "Content-Type: application/json" -X GET https://eu-api.legalesign.com/api/v1/group/

Node.js

import fetch from 'node-fetch';

async function getGroups() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/group/', {
    method: 'GET',
    headers: {
      'Authorization': 'ApiKey username:secret',
      'Content-Type': 'application/json',
    },
  });

  if (!response.ok) {
    throw new Error(`Request failed with status ${response.status}`);
  }

  const data = await response.json();
  console.log(data);
}

getGroups().catch((error) => {
  console.error(error);
  process.exit(1);
});

Python

import requests

headers = {
    "Authorization": "ApiKey username:secret",
    "Content-Type": "application/json",
}

response = requests.get(
    "https://eu-api.legalesign.com/api/v1/group/",
    headers=headers,
    timeout=30,
)
response.raise_for_status()

print(response.json())

C#

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Get,
            "https://eu-api.legalesign.com/api/v1/group/"
        );

        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey username:secret");
        request.Headers.TryAddWithoutValidation("Content-Type", "application/json");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var body = await response.Content.ReadAsStringAsync();
        Console.WriteLine(body);
    }
}

Go

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://eu-api.legalesign.com/api/v1/group/", nil)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey username:secret")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		log.Fatalf("request failed: %s", resp.Status)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(body))
}

API-Dokumentation: GET Gruppen API-Referenz.

Wenn Sie die obenstehende Abfrage ausführen, sehen Sie Ihre Gruppen in JSON zurückgegeben. Erfolg. 👏

Die Antwortdaten enthalten den „resource uri“ für Ihre Gruppe, z. B. /api/v1/group/:groupId/. Merken Sie sich diesen, Sie benötigen ihn für die meisten API-Aufrufe.

Tipp

Ein resource uri hat immer das gleiche Format. Für ein PDF wäre das '/api/v1/templatepdf/:pdfId/', für ein gesendetes Dokument '/api/v1/document/:documentId/'. Achten Sie darauf, dass alle URIs mit einem Schrägstrich enden. Das gilt auch für die URLs Ihrer API-Aufrufe, immer mit einem Schrägstrich abschließen.

Wenn die GET-Anfrage fehlschlägt, überprüfen Sie:

• ob Ihr ApiKey korrekt formatiert ist (beginnt mit 'ApiKey'),
• ob Sie einen Content-Type Header für application/json haben, und
• ob Ihre URL mit einem Schrägstrich endet.

Siehe auch Fehlerbehebung.

3. Laden Sie ein Dokument über die Web-App hoch

Zum Start laden wir ein Dokument über die Web-App hoch und senden es über die API. Später behandeln wir wie man ein Dokument über die API hochlädt.

Gehen Sie zur Web-App und laden Sie Ihr Dokument hoch. Fügen Sie eine einzelne Signiererrolle hinzu und ziehen Sie ein Unterschriftsfeld darauf. Die Editor-Seite zeigt an, ob das Dokument „gültig“ ist (ein Beispiel für „ungültig“ wäre, wenn Sie eine Signiererrolle ohne zugehöriges Unterschriftsfeld hinzufügen).

Kopieren Sie in der Formular-Editor-Ansicht die lange alphanumerische ID aus der URL, decodieren Sie sie base64 und verwerfen Sie die ersten 3 Buchstaben (die „tpl“ sein sollten). Der Rest ist eine UUID, die Ihre ID ist.

In REST-API-Sprache lautet der resource uri für dieses Dokument /api/v1/templatepdf/UUID/.

Mehr über Web- und API-IDs erfahren.

Unsere Nomenklatur ist, dass ein hochgeladenes Dokument eine „Vorlage“ ist und beim Versenden erstellen Sie ein „Dokument“.

Tipp

Wenn Sie eine Vorlage beim Senden archivieren wollen, setzen Sie 'archive_upon_send' als Attribut in der Upload-Anfrage. Wenn die Vorlage nie erscheinen und nach dem Senden gelöscht werden soll, geben Sie ihr den Titel '[deleted]' – unsere Bereinigungssysteme erkennen dies und löschen sie nach ein oder zwei Tagen. Sie können auch kurzlebige Aufbewahrungszeiten auf Gruppenebene einstellen – mehr erfahren.

4. Senden Sie ein Dokument zur Unterschrift

Jetzt senden wir das über die API. Denken Sie daran, eine E-Mail aus Ihren sandbox-genehmigten E-Mails zu verwenden. Verwenden Sie die untenstehenden Tabs, um die Anfrage in Ihrer bevorzugten Sprache zu kopieren.

cURL

curl -H "Authorization: ApiKey [username]:[secret]" -H "Content-Type: application/json" -X POST --data '{ "group": "/api/v1/group/[:groupId]/", "name": "Name of doc", "templatepdf": "/api/v1/templatepdf/UUID/", "signers": [{"firstname": "Joe", "lastname": "Bloggs", "email": "[your@email.com]", "order": 0 }], "do_email": true }' https://eu-api.legalesign.com/api/v1/document/

Node.js

import fetch from 'node-fetch';

const payload = {
  group: '/api/v1/group/[:groupId]/',
  name: 'Name of doc',
  templatepdf: '/api/v1/templatepdf/UUID/',
  signers: [
    {
      firstname: 'Joe',
      lastname: 'Bloggs',
      email: '[your@email.com]',
      order: 0,
    },
  ],
  do_email: true,
};

async function sendDocument() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/document/', {
    method: 'POST',
    headers: {
      'Authorization': 'ApiKey [username]:[secret]',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload),
  });

  if (response.status !== 201) {
    const errorBody = await response.text();
    throw new Error(`Request failed with status ${response.status}: ${errorBody}`);
  }

  console.log('Document sent successfully');
  const location = response.headers.get('location');
  if (location) {
    console.log(`Location: ${location}`);
  }
}

sendDocument().catch((error) => {
  console.error(error);
  process.exit(1);
});

Python

import requests

payload = {
    "group": "/api/v1/group/[:groupId]/",
    "name": "Name of doc",
    "templatepdf": "/api/v1/templatepdf/UUID/",
    "signers": [
        {
            "firstname": "Joe",
            "lastname": "Bloggs",
            "email": "[your@email.com]",
            "order": 0,
        }
    ],
    "do_email": true,
}

headers = {
    "Authorization": "ApiKey [username]:[secret]",
    "Content-Type": "application/json",
}

response = requests.post(
    "https://eu-api.legalesign.com/api/v1/document/",
    json=payload,
    headers=headers,
    timeout=30,
)
response.raise_for_status()

print("Document sent successfully")
print("Location:", response.headers.get("Location"))

C#

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        var payload = new
        {
            group = "/api/v1/group/[:groupId]/",
            name = "Name of doc",
            templatepdf = "/api/v1/templatepdf/UUID/",
            signers = new[]
            {
                new
                {
                    firstname = "Joe",
                    lastname = "Bloggs",
                    email = "[your@email.com]",
                    order = 0,
                },
            },
            do_email = true,
        };

        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Post,
            "https://eu-api.legalesign.com/api/v1/document/"
        );
        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey [username]:[secret]");

        var json = JsonSerializer.Serialize(payload);
        request.Content = new StringContent(json, Encoding.UTF8, "application/json");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        Console.WriteLine("Document sent successfully");
        if (response.Headers.Location is not null)
        {
            Console.WriteLine($"Location: {response.Headers.Location}");
        }
    }
}

Go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

func main() {
	payload := map[string]any{
		"group": "/api/v1/group/[:groupId]/",
		"name":  "Name of doc",
		"templatepdf": "/api/v1/templatepdf/UUID/",
		"signers": []map[string]any{
			{
				"firstname": "Joe",
				"lastname":  "Bloggs",
				"email":     "[your@email.com]",
				"order":     0,
			},
		},
		"do_email": true,
	}

	body, err := json.Marshal(payload)
	if err != nil {
		log.Fatal(err)
	}

	req, err := http.NewRequest(
		http.MethodPost,
		"https://eu-api.legalesign.com/api/v1/document/",
		bytes.NewReader(body),
	)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey [username]:[secret]")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		log.Fatalf("unexpected status: %s", resp.Status)
	}

	fmt.Println("Document sent successfully")
	fmt.Println("Location:", resp.Header.Get("Location"))
}

Ersetzen Sie alle eckigen Klammern. API-Referenz zum Senden eines Dokuments.

Tipp

Wenn Sie die Referenzdokumentation zum Senden eines Dokuments besuchen, schauen Sie sich alle möglichen Attribute genau an. Sie werden viele finden, die bei der Praxis einer Integration helfen – Tags für eigene Verweise und IDs (die in Webhooks zurückkommen), eine Weiterleitung für Unterzeichner, benutzerdefinierten Text im PDF setzen und mehr.

Ein erfolgreicher Aufruf gibt den Statuscode 201 zurück. ✨

Erhalten Sie die neue ID des gesendeten Dokuments

Der wichtige Teil der Antwort ist der Location-Header. Dieser enthält Ihre neue Dokumenten-ID.

Tipp

Verwenden Sie Dokument-„Tag“-Attribute und fügen Sie Ihre eigenen Referenzen hinzu, um es einfacher zu machen, mit Ihrer eigenen Datenbank abzugleichen.

Der Location-Header sieht aus wie /api/v1/status/:documentId/.

Die 'status'-URI liefert eine kurze (und schnell abfragbare) Menge an Dokumentattributen.

Um alles von einem Dokument anzufordern, verwenden Sie /api/v1/document/:documentId/.

Info

Wenn eine Anfrage nicht erfolgreich ist, enthält der BODY der Antwort meist Fehlermeldungen. Wenn Sie keinen Erfolgsstatus erhalten, prüfen Sie den BODY auf erklärenden Text. Siehe auch Fehlerbehebung.

Mehr über den API-Aufruf Send Document erfahren.

5. Laden Sie das unterschriebene Dokument herunter

Mit der oben erhaltenen gesendeten Dokument-ID führen Sie eine PDF-Download-Anfrage in der Sprache Ihrer Wahl durch:

cURL

curl -H "Authorization: ApiKey [username]:[secret]" -o download.pdf -X GET https://eu-api.legalesign.com/api/v1/pdf/:documentId/

Node.js

import { writeFile } from 'node:fs/promises';
import fetch from 'node-fetch';

async function downloadPdf() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/pdf/:documentId/', {
    method: 'GET',
    headers: {
      'Authorization': 'ApiKey [username]:[secret]',
    },
  });

  if (!response.ok) {
    throw new Error(`Request failed with status ${response.status}`);
  }

  const buffer = await response.arrayBuffer();
  await writeFile('download.pdf', Buffer.from(buffer));
  console.log('Saved download.pdf');
}

downloadPdf().catch((error) => {
  console.error(error);
  process.exit(1);
});

Python

import requests

headers = {"Authorization": "ApiKey [username]:[secret]"}

response = requests.get(
    "https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
    headers=headers,
    stream=True,
    timeout=30,
)
response.raise_for_status()

with open("download.pdf", "wb") as file:
    for chunk in response.iter_content(chunk_size=8192):
        file.write(chunk)

C#

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        using var client = new HttpClient();
        using var request = new HttpRequestMessage(
            HttpMethod.Get,
            "https://eu-api.legalesign.com/api/v1/pdf/:documentId/"
        );
        request.Headers.TryAddWithoutValidation("Authorization", "ApiKey [username]:[secret]");

        using var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var bytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("download.pdf", bytes);
        Console.WriteLine("Saved download.pdf");
    }
}

Go

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(
		http.MethodGet,
		"https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
		nil,
	)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "ApiKey [username]:[secret]")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		log.Fatalf("request failed: %s", resp.Status)
	}

	file, err := os.Create("download.pdf")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	if _, err := io.Copy(file, resp.Body); err != nil {
		log.Fatal(err)
	}

	log.Println("Saved download.pdf")
}

PDF-Download API-Referenz.

Das PDF-Binärformat befindet sich im Body der Antwort. Der Curl-Befehl '-o' schreibt den BODY der Antwort direkt in eine Datei.

Viele REST- oder HTTP-Bibliotheken behandeln HTTP-Antwortobjekte wie Dateien, in diesem Fall speichern Sie Ihr Antwortobjekt einfach wie eine normale Datei.

Tipp

Verwenden Sie Webhooks, um über ein Unterschreibereignis benachrichtigt zu werden und dann das Dokument herunterzuladen. Siehe Webhooks.

6. Laden Sie ein PDF hoch

Klicken Sie hier, um ein Beispiel eines text-getaggten PDFs herunterzuladen, mehr zu PDF-Formularfeldern folgt.

Für diesen Aufruf wandeln Sie Ihr PDF in einen base64-codierten String um. Dies wird in der Dokumentations-Code-Generator nicht korrekt gemacht. Stattdessen kopieren Sie diesen Pseudocode und Ihre freundliche KI konvertiert ihn in Ihre bevorzugte Sprache:

$data = (
  'group': '/api/v1/group/:groupId/',
  'title': 'title of pdf',
  'pdf_file': base64encode(open('/path/to/file','rb')),
  'process_tags': true
)
$headers = (
  'Authorization': 'ApiKey username:secret',
  'Content-Type': 'application/json'
)
response = httplibrary.post('https://eu-api.legalesign.com/api/v1/templatepdf/', jsonEncode($data), $headers)
assert response.status == 201

pdfId = response.headers['location']

PDF-Upload API-Referenz.

Wie üblich gibt eine erfolgreiche POST-Antwort den Status '201' zurück und die neue ID befindet sich im Location-Header der Antwort.

assert response.status == 201
pdfId = response.headers['location']

Ihr PDF resource URI sieht aus wie /api/v1/templatepdf/:pdfId/.

Senden Sie das neue PDF

Gehen Sie zurück zum verwendeten Code, mit dem Sie Ihr erstes Dokument gesendet haben, und ersetzen Sie den templatepdf-Wert.

Führen Sie die Anfrage erneut aus und fertig, Sie haben Ihr PDF zum Unterschreiben versendet.

Bevor Sie jedoch mit dem Codieren beginnen, lesen Sie weiter, um mehr über PDF-Felder zu erfahren.

Wie sieht es mit PDF-Feldern aus?

Wie weiß Legalesign, wo die Person auf dem PDF unterschreiben muss oder welche Bereiche beim Versenden geändert werden? Die Antwort ist, dass unser PDF vorab mit Tags versehen wurde: wir setzen einen Legalesign-Text-Tag innerhalb des PDFs und setzen 'process_tags' auf true in der PDF-Upload-Anfrage.

Ein Beispiel eines text-getaggten PDFs herunterladen.

Text-Tags sind speziell formatierter Text, der in ein PDF eingefügt wird. Legalesign parst den Text in Ihrer Datei und ersetzt die Tags durch Unterschrifts- und Formularfelder. Für einen Unterzeichner müssen Sie nur <<t=signature>> hinzufügen. Legalesign erkennt dies und platziert die Unterschrift dort. Mehr über Text-Tags erfahren.

Text-Tags haben eine Lernkurve und benötigen Versuch und Irrtum. Andere Methoden werden unten beschrieben, aber mit Text-Tags erhalten Sie die volle Funktionalität des Legalesign-Formularsystems. Verwenden Sie die Web-App zum Testen von Tags. Kontaktieren Sie den Support für Hilfe und Beispiele.

Hier sind 4 weitere Möglichkeiten, Felder einzurichten:

1. Einfachste/schnellste Version. Richten Sie Ihr PDF über die Legalesign-Web-App ein.

Nach dem Hochladen eines PDFs gelangen Sie zur Editor-Oberfläche, wo Sie Formularfelder per Drag & Drop hinzufügen können.

Ziehen Sie eine Unterschrift, notieren Sie die kodierte ID in der Webadresse. Diese sieht ungefähr so aus: 'dHBsMTRlZTQ0ZWUtZGE0Ni0xMWVmLTllZmUtMDI5ZGQ0ODkzZGRk'.

Dekodieren Sie diese ID Base64, Sie sehen, dass es eine UUID mit dem Präfix 'tpl' ist. Der UUID-Teil (ohne 'tpl') ist Ihre pdfID. Mehr über Legalesign-IDs erfahren.

Ihr API PDF resource uri lautet: /api/v1/templatepdf/:pdfId/.

Setzen Sie diesen Wert in das Attribut 'templatepdf' beim Senden eines Dokuments ein.

Info

Wenn Sie dieses PDF mehr als einmal senden möchten, stellen Sie sicher, dass „Auto-Archivierung“ deaktiviert ist. So geht's

2. Verwendung von x/y-Koordinaten für Felder.

Der einfachste Weg, mit x/y-Koordinaten zu beginnen, ist, ein PDF in der Web-App einzurichten und dann die Felder per API abzufragen (GET PDF-Felder - /api/v1/templatepdf/:pdfId/fields/).

Das zurückgegebene JSON-Objekt ist genau die JSON-Schema, die Sie auch zum Erstellen von Feldern verwenden müssen.

Nutzen Sie es als Vorlage. Ändern Sie Werte und senden Sie es per POST an die gleiche Endpoint erneut (passen Sie die PDF-ID entsprechend an). PDF-Feld-Endpunkt erstellen.

3. Betten Sie unsere PDF-Bearbeitungsseite ein. NEU!

Verwenden Sie unsere Editor-Komponente, um unseren PDF-Editor direkt in Ihre eigene App einzubetten. Mehr über die Dokument-Editor-Komponente erfahren.

4. PDF-Formularfelder NEU!

Wenn Ihr PDF normale PDF-Formularfelder enthält, kann Legalesign sie automatisch importieren.

Viel Erfolg beim Programmieren!

In diesem Tutorial haben Sie API-Zugangsdaten erhalten, erfolgreich nach Ihren Gruppen gesucht, ein Dokument zum Signieren gesendet (sowohl als HTML als PDF) und ein unterschriebenes Dokument heruntergeladen.

Viel Erfolg beim Programmieren! Wir sind hier, um zu helfen, kontaktieren Sie Support für jede Unterstützung.

Tipp

Super, Sie haben es bis zum Ende geschafft – danke fürs Lesen. Unsere letzte Bitte und Tipp, basierend auf jahrelanger Erfahrung mit Entwicklern, die diese API integrieren: Nehmen Sie sich einen Moment, um alle Attribute auf dem Create-Document-Endpunkt durchzulesen (und klicken Sie sich durch, um zu sehen, was 'signers', 'pdftext' und 'signertext' enthalten) – das ist der wichtigste Aufruf in Ihrer Integration. Ein Dokument zum Signieren erstellen.

Nächste Schritte:

• Webhooks für Echtzeit-Benachrichtigungen
• Betten Sie den Formular-Editor ein
• Betten Sie die Signing-Seite ein