Tiwtorial Dechrau Cyflym

cyngor

Yn defnyddio Cursor, Claude, neu offer codio AI arall? Cysylltwch ef â dogfennau Legalesign i gael help cyd-destunol wrth ddilyn y tiwtorial hwn.

Yn y tiwtorial hwn byddwch yn cwblhau’r galwadau API allweddol sydd eu hangen ar y rhan fwyaf o ddatblygwyr o integreiddiad eSignature - uwchlwytho dogfen a’i hanfon allan i’w llofnodi.

Mae API Legalesign yn raddadwy, amrywiol, ac wedi cael ei brofi mewn cynhyrchiad mewn systemau ein cwsmeriaid am flynyddoedd lawer. Gallwch ei ddefnyddio ar gyfer dogfen un llofnodwr syml, neu anfon dogfennau i gael dystiolaeth neu gymeradwyaethau, wedi’i optimeiddio ar gyfer swmpiau, gyda ffurflenni a mwy. Gallwch integreiddio at un diben neu ei ymgorffori o fewn eich meddalwedd ar gyfer eich cwsmeriaid - gweler integreiddiadau.

Mae’r REST API yn perfformio’r mwyafrif o swyddogaethau ac yn y ffordd hawsaf i ddechrau. Os oes angen mwy arnoch gwiriwch y ryngwyneb GraphQL. Mae Legalesign yn API yn gyntaf gyda GraphQL. Gallwch ddefnyddio un neu’r llall, yn ôl eich dewisiad.

Byddwn yn dilyn y camau canlynol:

1. Creu cyfrif + Allwedd API (gweler Sicrhau mynediad API).
2. Cadarnhau bod y tystysgrifau’n gweithio a chael ID eich tîm.
3. Uwchlwytho dogfen drwy’r ap gwe.
4. Anfon hynny i’w lofnodi trwy’r API.
5. Lawrlwytho’r dogfen ar ôl llofnodi.
6. Uwchlwytho dogfen drwy’r API.

Mae REST API Legalesign yn hawdd i’w ddefnyddio. Mae’r cyfeirlyfr technegol yn cynnwys golygydd cod. Gallwch wneud ceisiadau’n uniongyrchol o’r cyfeirlyfr technegol gyda’ch allwedd api, ond fel arall dim ond copïo a gludo’n uniongyrchol i’ch cod.

Ffigur 1: Golygydd Cod REST API.

Llyfrgelloedd cleient

• C# + Sut i
• Java
• Node.js
• PHP
• Python
• Ruby

Neu ar gyfer y rhyngwyneb GraphQL Node.js

cyngor

Rydym yn argymell i ddatblygwyr weithio’n uniongyrchol gyda’r API yn lle’r SDKs. Er mwyn helpu, mae gennym generator cod torri-a-gludo yn y maniffest technegol, ac mae eich AI yn gallu creu enghreifftiau’n gyflym gan ddefnyddio’r maniffest OpenAPI. Pam? Mae’r API ffynhonnell yn cynnig mwy o swyddogaethau na’r SDKs, byddwch yn dymuno gwybod am y penawdau a ddefnyddiwch beth bynnag, byddwch yn osgoi gorbennaeth ac ymlyniadau, a – yn seiliedig ar ein profiad – bydd yn mynd yn gynt hefyd.

1. Creu cyfrif

Ewch i cofrestru gyda legalesign a dilynwch y broses i greu cyfrif.

Byddwch yn cael eich gofyn i greu tîm. Mae timau yn seiliau Legalesign. Mae’r holl brosesu dogfennau yn digwydd mewn tîm. Mae angen i chi gyfeirio at eich tîm yn y mwyafrif o alwadau API.

gwybodaeth

‘Tîm’ neu ‘grŵp’ yw’r un peth. Yn yr ap gwe rydym yn siarad am ‘dimau’, ond yn strwythur yr API mae’n grŵp.

Gosodiadau API

Ewch i’r Dashboard API. Cynhyrchwch eich tystysgrifau API yn adran Allwedd API.

Cymerwch funud i adolygu’r Porth Datblygwr.

Amgylchedd Sandbox

Yn yr adran Amgylchedd, mae rhybudd yn dangos os ydych chi mewn modd sandbox neu gynhyrchiad.

Mae modd sandbox yn gosod terfyn o 100 o alwadau yr awr. Nid oes cyfyngiadau ar gyfeiriadau e-bost derbynyddion.

Pan fydd eich integreiddiad yn barod: symud i’r modd cynhyrchiad.

cyngor

Creu ail dîm. Defnyddiwch eich tîm cyntaf ar gyfer datblygu a thîm(au) eraill ar gyfer cynhyrchiad. Dywedwch wrth gefnogaeth enw eich tîm datblygu i’w eithrio o daliadau.

Allwedd API

Yn yr Adran Allwedd API fe welwch fanylion eich allweddi API. Dim ond i chi ddangosir y allwedd ei hun wrth greu un.

Mae'r adran Dechrau Cyflym yn cynnwys enghreifftiau torri-a-gludo i brofi’ch allwedd.

Webhooks a Logiau

Ychwanegu webhooks (eich gwrandawyr ar ddigwyddiadau Legalesign), a gwiriwch eich logiau.

2. Cais GET llwyddiannus

Mae’r URL gwraidd bob amser yn: https://eu-api.legalesign.com/

Dechreuwch gyda chais GET i gadarnhau bod eich tystysgrifau’n gweithio. Disodli your_api_key gyda’ch allwedd o’r Porth Datblygwr.

Defnyddir Curl yn yr enghreifftiau, ac gallwch newid rhwng cURL, Node.js, Python, C#, a Go gan ddefnyddio’r tabiau isod.

cURL

curl -H "Authorization: Bearer your_api_key" -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': 'Bearer your_api_key',
      '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": "Bearer your_api_key",
    "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", "Bearer your_api_key");
        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", "Bearer your_api_key")
	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))
}

Dogfen API: Cyfeirlyfr API grŵp GET.

Pan fyddwch yn gweithredu’r ymholiad uchod, fe welwch eich grwpiau’n cael eu dychwelyd mewn JSON. Llwyddiant. 👏

Mae data’r ymateb yn cynnwys 'resource uri' ar gyfer eich grŵp ac mae’n edrych fel /api/v1/group/:groupId/. Nodwch hyn, bydd ei angen arnoch ar gyfer y mwyafrif o alwadau API.

cyngor

Bydd URI adnodd yn cael ei fformatio’r un fath bob amser. Ar gyfer PDF byddai’n '/api/v1/templatepdf/:pdfId/', ar gyfer dogfen a anfonwyd bydd yn '/api/v1/document/:documentId/'. Sylwch sut mae pob URI yn gorffen gyda sleis, mae hynny hefyd yn wir am URLau eich galwadau API, gorffennwch nhw bob amser gyda sleis.

Os methiant y cais GET yna gwiriwch a:

• mae’ch penawd Authorization wedi’i fformatio’n gywir (yn dechrau gyda Bearer ),
• oes penawd Content-Type ar gyfer application/json, a
• mae’ch URL yn gorffen gydag sleis.

Gweler hefyd datrys problemau.

3. Uwchlwytho dogfen drwy’r ap gwe

I ddechrau, byddwn yn uwchlwytho dogfen trwy’r ap gwe ac yn anfon hynny trwy’r API. Byddwn yn trafod sut i uwchlwytho dogfen trwy’r API yn nes ymlaen.

Ewch i’r ap gwe a uwchlwythwch eich dogfen. Ychwanegwch rôl llofnodwr sengl a llusgwch i ardal arwydd. Bydd y dudalen golygydd yn nodi os yw’r ddogfen yn ‘ddilys’ (enghraifft o ‘annilys’ efallai pe byddech yn ychwanegu rôl llofnodwr heb faes arwydd cysylltiedig).

Ar y golygydd ffurflen, copïwch y ID hir alffaniwmerig o’r URL, dadgodwch ef base64 a gwaredwch y tri llythyren gyntaf (dylai fod ‘tpl’). Y gweddill yw UUID sydd yw eich ID.

Yn iaith REST API, y resource uri ar gyfer y ddogfen hon yw /api/v1/templatepdf/UUID/.

Darllenwch fwy am IDs gwe a API.

Ein nôl term yw bod dogfen uwchlwythwyd yn ‘templed’ a phan anfonwch un, rydych yn creu ‘dogfen’.

cyngor

Os ydych am archifo templed pan anfonir y ddogfen setiwch 'archive_upon_send' fel priodoledd yn yr cais uwchlwytho. Os ydych am i’r templed byth ymddangos a’i ddileu ar ôl ei anfon, rhowch y teitl '[deleted]' – bydd ein systemau glanhau yn ei ganfod ac yn ei ddileu ar ôl diwrnod neu ddau. Gallwch hefyd osod amseroedd cadw data byr ar lefel y grŵp - dysgwch fwy.

4. Anfon dogfen i’w llofnodi

Nawr byddwn yn ei anfon trwy’r API. Defnyddiwch y tabiau isod i gopïo’r cais yn eich iaith ffefryn.

cURL

curl -H "Authorization: Bearer your_api_key" -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': 'Bearer your_api_key',
      '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": "Bearer your_api_key",
    "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", "Bearer your_api_key");

        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", "Bearer your_api_key")
	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"))
}

Diweddarwch yr holl gromfachau sgwâr. Cyfeirlyfr API anfon dogfen.

cyngor

Pan fyddwch yn ymweld â’r dogfen cyfeirio ar gyfer anfon dogfen edrychwch drwy’r holl briodweddau posibl. Byddwch yn gweld llawer a fydd yn helpu gyda’r ymarferoldeb integreiddiad – tagiau ar gyfer eich cyfeiriadau a IDs eich hun (y maent yn dychwelyd i chi mewn webhooks), ailgyfeiriad ar gyfer llofnodwyr, gosod testun arferol yn y pdf, a mwy.

Bydd galwad llwyddiannus yn dychwelyd cod statws 201. ✨

Cael y newid ID dogfen anfon

Y rhan bwysig o’r ymateb yw’r penawd location. Mae hwn yn cynnwys eich ID dogfen newydd.

cyngor

Defnyddiwch ‘tag’ dogfen a ychwanegwch eich cyfeiriadau eich hun i’w hwyluso i gysylltu gyda’ch cronfa ddata eich hun.

Bydd y penawd location fel /api/v1/status/:documentId/.

Mae URI ‘status’ yn dychwelyd set fer (ac yn gyflym i ymchwilio) o briodweddau dogfen.

I wneud cais am bopeth o ddogfen, defnyddiwch /api/v1/document/:documentId/.

gwybodaeth

Os nad yw cais yn llwyddiannus, fel arfer bydd CORFF yr ymateb yn cynnwys gwybodaeth am y gwall. Os nad ydych yn cael statws llwyddiant, gwiriwch y CORFF am destun eglurhaol. Gweler hefyd datrys problemau.

Darllenwch fwy am y galwad API Send Document.

5. Lawrlwytho dogfen wedi’i llofnodi

Gyda’r ID dogfen anfon a gawsoch uchod, gwnewch gais lawrlwytho PDF yn yr iaith o’ch dewis:

cURL

curl -H "Authorization: Bearer your_api_key" -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': 'Bearer your_api_key',
    },
  });

  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": "Bearer your_api_key"}

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", "Bearer your_api_key");

        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", "Bearer your_api_key")

	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")
}

Cyfeirlyfr API lawrlwytho PDF.

Mae’r binari PDF yn y corff ymateb. Mae’r gorchymyn curl '-o' yn rhoi CORFF yr ymateb yn uniongyrchol i ffeil.

Mae llawer o lyfrgelloedd REST neu HTTP yn trin gwrthrychau ymateb HTTP fel pe baent yn ffeiliau, felly dim ond cadw’ch gwrthrych ymateb fel ffeil arferol.

cyngor

Defnyddiwch webhooks i gael hysbysiad o ddigwyddiad llofnodi ac yna lawrlwythwch y ddogfen. Gweler webhooks.

6. Uwchlwytho PDF

Cliciwch yma i lawrlwytho PDF cyfeirio testun sampl, mwy am feysydd ffurflen PDF i ddilyn.

Ar gyfer y galwad hon, troswch eich PDF yn gadwyn wedi’i amgodio base64. Nid yw hyn yn cael ei wneud yn iawn drwy’r generator cod yn y ddogfennaeth. Yn lle hynny, copïwch y pseudocod hwn a bydd eich AI cyfeillgar yn ei drawsnewid i’ch iaith ffefryn:

$data = (
  'group': '/api/v1/group/:groupId/',
  'title': 'title of pdf',
  'pdf_file': base64encode(open('/path/to/file','rb')),
  'process_tags': true
)
$headers = (
  'Authorization': 'Bearer your_api_key',
  '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']

Cyfeirlyfr API uwchlwytho PDF.

Fel arfer, bydd ymateb POST llwyddiannus yn dychwelyd statws ‘201’, a bydd yr ID newydd yn y penawd ‘location’ yn yr ymateb.

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

Bydd eich URI adnodd pdf yn edrych fel /api/v1/templatepdf/:pdfId/.

Anfon y PDF newydd

Dychwelwch at y cod a ddefnyddiodd i anfon eich dogfen gyntaf, a disodli’r gwerth templatepdf.

Anfonwch y cais eto a dyna ni, anfonwyd eich PDF allan i’w lofnodi.

Cyn dechrau codio, fodd bynnag, darllenwch ymlaen i ddysgu mwy am feysydd PDF.

Beth am feysydd PDF?

Sut mae Legalesign yn gwybod ble mae angen i’r person lofnodi ar y PDF, neu adrannau i’w newid wrth anfon? Y ateb yw bod ein PDF wedi’i baratoi ymlaen llaw gyda thagiau: fe wnaethom roi tag testun Legalesign o fewn y PDF a gosodon ni ‘process_tags’ i wir yn y cais uwchlwytho PDF.

Llawrlwythwch PDF cyfeirio testun sampl.

Mae tagiau testun yn destun wedi’i fformatio arbennig i’w roi mewn PDF. Bydd Legalesign yn dadansoddi’r testun yn eich ffeil, gan ddisodli’r tagiau gyda meysydd llofnodi a ffurflenni. Ar gyfer un llofnodwr dim ond ychwanegu: <<t=signature>> sydd ei angen arnoch. Bydd Legalesign yn ei adnabod a'i leoli yno. Dysgwch am dagiau testun.

Mae tagiau testun yn galw am ddysgu drwy dreial a chamgymeriad. Mae dulliau eraill isod, ond mae gennych y gallu cyflawn i’r system ffurflenni Legalesign gyda nhw. Defnyddiwch yr ap gwe i brofi tagiau. Cysylltwch â chefnogaeth am gymorth ac enghreifftiau.

Dyma 4 ffordd arall i sefydlu meysydd:

1. Fersiwn hawsaf/gyflymaf. Sefydlu’ch PDF gan ddefnyddio’r ap gwe Legalesign.

Ar ôl i chi uwchlwytho PDF, fe gewch y rhyngwyneb golygydd lle gallwch lusgo a rhoi meysydd ffurflen.

Llusgwch arwydd, wedyn nodwch yr ID codiedig yn y cyfeiriad gwe. Bydd hyn yn edrych rhywbeth fel ‘dHBsMTRlZTQ0ZWUtZGE0Ni0xMWVmLTllZmUtMDI5ZGQ0ODkzZGRk’.

Dadgodwch y ID hwn wrth ddefnyddio base64 a gwelwch ei fod yn UUID gyda’r rhagddodiad ‘tpl’. Y rhan UUID (tynnwch ‘tpl’) yw’ch pdfID. Dysgwch fwy am IDs Legalesign.

Bydd eich URI adnodd API PDF - /api/v1/templatepdf/:pdfId/.

Rhowch hwnnw i’r briodwedd ‘templatepdf’ o’r galwad anfon dogfen.

gwybodaeth

Os ydych yn bwriadu anfon y PDF hwn droeon, sicrhewch fod ‘Archifo awtomatig’ wedi’i ddiffodd. Gweler sut

2. Defnyddiwch gydlynnau x/y ar gyfer meysydd.

Y ffordd symlaf i ddechrau gyda chydlynnau x/y yw gosod PDF yn yr ap gwe ac yna chwilio drwy API am y meysydd hynny (GET PDF Fields - /api/v1/templatepdf/:pdfId/fields/).

Mae’r gwrthrych JSON a gewch yn ôl yn union yr un schema JSON yw’r un sydd ei angen i greu meysydd hefyd.

Defnyddiwch ef fel templed. Addaswch unrhyw werthoedd a POSTiwch ef yn ôl i’r un penawd (gan addasu’r ID PDF yn un priodol). Creu penawd maes PDF.

3. Mewnosodwch ein tudalen golygu PDF. NEWYDD!

Defnyddiwch ein cydran olygwr i fewnosod ein golygydd PDF yn union yn eich ap eich hun. Dysgwch fwy am y cydran golygydd dogfen.

4. Meysydd Ffurflen PDF NEWYDD!

Os yw’ch PDF yn cynnwys Meysydd Ffurflen PDF arferol, gall Legalesign eu mewnforio’n awtomatig.

Codio hapus!

Yn y tiwtorial hwn daethoch i feddu ar dystysgrifau API, gwnaethoch ymholiad llwyddiannus am eich grwpiau, anfonwyd dogfen i’w llofnodi gan ddefnyddio HTML a PDF, a lawrlwythoch ddogfen wedi’i llofnodi.

Codio hapus! Rydym yma i helpu, cysylltwch â chefnogaeth am unrhyw gymorth.

cyngor

Da iawn, cyrhaeddoch y diwedd - diolch am ddarllen hyn. Ein cais olaf, a chyngor, yn seiliedig ar flynyddoedd o brofiad gyda datblygwyr yn integreiddio gyda’r API hwn, yw y cymmerwch funud i ddarllen drwy’r holl briodweddau yn y penawd creu dogfen (a cliciwch i weld beth mae ‘signers’, ‘pdftext’ a ‘signertext’ yn cynnwys) – dyma’r galwad bwysicaf yn eich integreiddiad. Creu dogfen ar gyfer llofnodi.

Camau nesaf:

• Webhooks ar gyfer hysbysiadau amser real
• Mewnosod y golygydd ffurflenni
• Mewnosod y dudalen llofnodi